gold/arm-reloc-property.cc

   1 // arm-reloc-property.cc -- ARM relocation property.
   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 #include "gold.h"
  24
  25 #include <cstdio>
  26 #include <cstring>
  27 #include <stack>
  28 #include <string>
  29 #include <vector>
  30
  31 #include "elfcpp.h"
  32 #include "arm.h"
  33 #include "arm-reloc-property.h"
  34
  35 namespace gold
  36 {
  37
  38 // Arm_reloc_property::Tree_node methods.
  39
  40 // Parse an S-expression S and build a tree and return the root node.
  41 // Caller is responsible for releasing tree after use.
  42
  43 Arm_reloc_property::Tree_node*
  44 Arm_reloc_property::Tree_node::make_tree(const std::string& s)
  45 {
  46   std::stack<size_t> size_stack;
  47   Tree_node_vector node_stack;
  48
  49   // strtok needs a non-const string pointer.
  50   char* buffer = new char[s.size() + 1];
  51   memcpy(buffer, s.data(), s.size());
  52   buffer[s.size()] = '\0';
  53   char* token = strtok(buffer, " ");
  54
  55   while (token != NULL)
  56     {
  57       if (strcmp(token, "(") == 0)
  58         // Remember the node stack position for start of a new internal node.
  59         size_stack.push(node_stack.size());
  60       else if (strcmp(token, ")") == 0)
  61         {
  62           // Pop all tree nodes after the previous '(' and use them as
  63           // children to build a new internal node.  Push internal node back.
  64           size_t current_size = node_stack.size();
  65           size_t prev_size = size_stack.top();
  66           size_stack.pop();
  67           Tree_node* node =
  68             new Tree_node(node_stack.begin() + prev_size,
  69                           node_stack.begin() + current_size);
  70           node_stack.resize(prev_size);
  71           node_stack.push_back(node);
  72         }
  73       else
  74         // Just push a leaf node to node_stack.
  75         node_stack.push_back(new Tree_node(token));
  76
  77       token = strtok(NULL, " ");
  78     }
  79
  80   delete[] buffer;
  81
  82   // At this point, size_stack should be empty and node_stack should only
  83   // contain the root node.
  84   gold_assert(size_stack.empty() && node_stack.size() == 1);
  85   return node_stack[0];
  86 }
  87
  88 // Arm_reloc_property methods.
  89
  90 // Constructor.
  91
  92 Arm_reloc_property::Arm_reloc_property(
  93     unsigned int code,
  94     const char* name,
  95     Reloc_type rtype,
  96     bool is_deprecated,
  97     Reloc_class rclass,
  98     const std::string& operation,
  99     bool is_implemented,
 100     int group_index,
 101     bool checks_overflow)
 102   : code_(code), name_(name), reloc_type_(rtype), reloc_class_(rclass),
 103     group_index_(group_index), size_(0), align_(1),
 104     relative_address_base_(RAB_NONE), is_deprecated_(is_deprecated),
 105     is_implemented_(is_implemented), checks_overflow_(checks_overflow),
 106     uses_got_entry_(false), uses_got_origin_(false), uses_plt_entry_(false),
 107     uses_thumb_bit_(false), uses_symbol_base_(false), uses_addend_(false)
 108 {
 109   // Set size and alignment of static and dynamic relocations.
 110   if (rtype == RT_STATIC)
 111     {
 112       switch (rclass)
 113         {
 114         case RC_DATA:
 115           // Except for R_ARM_ABS16 and R_ARM_ABS8, all static data relocations
 116           // have size 4.  All static data relocations have alignment of 1.
 117           if (code == elfcpp::R_ARM_ABS8)
 118             this->size_ = 1;
 119           else if (code == elfcpp::R_ARM_ABS16)
 120             this->size_ = 2;
 121           else
 122             this->size_ = 4;
 123           this->align_ = 1;
 124           break;
 125         case RC_MISC:
 126           // R_ARM_V4BX should be treated as an ARM relocation.  For all
 127           // others, just use defaults.
 128           if (code != elfcpp::R_ARM_V4BX)
 129             break;
 130           // Fall through.
 131         case RC_ARM:
 132           this->size_ = 4;
 133           this->align_ = 4;
 134           break;
 135         case RC_THM16:
 136           this->size_ = 2;
 137           this->align_ = 2;
 138           break;
 139         case RC_THM32:
 140           this->size_ = 4;
 141           this->align_ = 2;
 142           break;
 143         default:
 144           gold_unreachable();
 145         }
 146     }
 147   else if (rtype == RT_DYNAMIC)
 148     {
 149       // With the exception of R_ARM_COPY, all dynamic relocations requires
 150       // that the place being relocated is a word-aligned 32-bit object.
 151       if (code != elfcpp::R_ARM_COPY)
 152         {
 153           this->size_ = 4;
 154           this->align_ = 4;
 155         }
 156     }
 157
 158   // If no relocation operation is specified, we are done.
 159   if (operation == "NONE")
 160     return;
 161
 162   // Extract information from relocation operation.
 163   Tree_node* root_node = Tree_node::make_tree(operation);
 164   Tree_node* node = root_node;
 165
 166   // Check for an expression of the form XXX - YYY.
 167   if (!node->is_leaf()
 168       && node->child(0)->is_leaf()
 169       && node->child(0)->name() == "-")
 170     {
 171       struct RAB_table_entry
 172       {
 173         Relative_address_base rab;
 174         const char* name;
 175       };
 176
 177       static const RAB_table_entry rab_table[] =
 178       {
 179         { RAB_B_S, "( B S )" },
 180         { RAB_DELTA_B_S, "( DELTA_B ( S ) )" },
 181         { RAB_GOT_ORG, "GOT_ORG" },
 182         { RAB_P, "P" },
 183         { RAB_Pa, "Pa" },
 184         { RAB_TLS, "TLS" },
 185         { RAB_tp, "tp" }
 186       };
 187
 188       static size_t rab_table_size = sizeof(rab_table) / sizeof(rab_table[0]);
 189       const std::string rhs(node->child(2)->s_expression());
 190       for (size_t i = 0; i < rab_table_size; ++i)
 191         if (rhs == rab_table[i].name)
 192           {
 193             this->relative_address_base_ = rab_table[i].rab;
 194             break;
 195           }
 196
 197       gold_assert(this->relative_address_base_ != RAB_NONE);
 198       if (this->relative_address_base_ == RAB_B_S)
 199         this->uses_symbol_base_ = true;
 200       node = node->child(1);
 201     }
 202
 203   // Check for an expression of the form XXX | T.
 204   if (!node->is_leaf()
 205       && node->child(0)->is_leaf()
 206       && node->child(0)->name() == "|")
 207     {
 208       gold_assert(node->number_of_children() == 3
 209                   && node->child(2)->is_leaf()
 210                   && node->child(2)->name() == "T");
 211       this->uses_thumb_bit_ = true;
 212       node = node->child(1);
 213     }
 214
 215   // Check for an expression of the form XXX + A.
 216   if (!node->is_leaf()
 217       && node->child(0)->is_leaf()
 218       && node->child(0)->name() == "+")
 219     {
 220       gold_assert(node->number_of_children() == 3
 221                   && node->child(2)->is_leaf()
 222                   && node->child(2)->name() == "A");
 223       this->uses_addend_ = true;
 224       node = node->child(1);
 225     }
 226
 227   // Check for an expression of the form XXX(S).
 228   if (!node->is_leaf() && node->child(0)->is_leaf())
 229     {
 230       gold_assert(node->number_of_children() == 2
 231                   && node->child(1)->is_leaf()
 232                   && node->child(1)->name() == "S");
 233       const std::string func(node->child(0)->name());
 234       if (func == "B")
 235         this->uses_symbol_base_ = true;
 236       else if (func == "GOT")
 237         this->uses_got_entry_ = true;
 238       else if (func == "PLT")
 239         this->uses_plt_entry_ = true;
 240       else if (func == "Module" || func == "DELTA_B")
 241         // These are used in dynamic relocations.
 242         ;
 243       else
 244         gold_unreachable();
 245       node = node->child(1);
 246     }
 247
 248   gold_assert(node->is_leaf() && node->name() == "S");
 249
 250   delete root_node;
 251 }
 252
 253 // Arm_reloc_property_table methods.
 254
 255 // Constructor.  This processing informations in arm-reloc.def to
 256 // initialize the table.
 257
 258 Arm_reloc_property_table::Arm_reloc_property_table()
 259 {
 260   // These appers in arm-reloc.def.  Do not rename them.
 261   Parse_expression A("A"), GOT_ORG("GOT_ORG"), NONE("NONE"), P("P"),
 262                    Pa("Pa"), S("S"), T("T"), TLS("TLS"), tp("tp");
 263   const bool Y(true), N(false);
 264
 265   for (unsigned int i = 0; i < Property_table_size; ++i)
 266     this->table_[i] = NULL;
 267
 268 #undef RD
 269 #define RD(name, type, deprecated, class, operation, is_implemented, \
 270            group_index, checks_oveflow) \
 271   do \
 272     { \
 273       unsigned int code = elfcpp::R_ARM_##name; \
 274       gold_assert(code < Property_table_size); \
 275       this->table_[code] = \
 276         new Arm_reloc_property(elfcpp::R_ARM_##name, "R_ARM_" #name, \
 277                                Arm_reloc_property::RT_##type, deprecated, \
 278                                Arm_reloc_property::RC_##class, \
 279                                (operation).s_expression(), is_implemented, \
 280                                group_index, checks_oveflow); \
 281     } \
 282   while(0);
 283
 284 #include "arm-reloc.def"
 285 #undef RD
 286 }
 287
 288 // Return a string describing a relocation code that fails to get a
 289 // relocation property in get_implemented_static_reloc_property().
 290
 291 std::string
 292 Arm_reloc_property_table::reloc_name_in_error_message(unsigned int code)
 293 {
 294   gold_assert(code < Property_table_size);
 295
 296   const Arm_reloc_property* arp = this->table_[code];
 297
 298   if (arp == NULL)
 299     {
 300       char buffer[100];
 301       sprintf(buffer, _("invalid reloc %u"), code);
 302       return std::string(buffer);
 303     }
 304
 305   // gold only implements static relocation codes.
 306   Arm_reloc_property::Reloc_type reloc_type = arp->reloc_type();
 307   gold_assert(reloc_type == Arm_reloc_property::RT_STATIC
 308               || !arp->is_implemented());
 309
 310   const char* prefix = NULL;
 311   switch (reloc_type)
 312     {
 313     case Arm_reloc_property::RT_STATIC:
 314       prefix = arp->is_implemented() ? _("reloc ") : _("unimplemented reloc ");
 315       break;
 316     case Arm_reloc_property::RT_DYNAMIC:
 317       prefix = _("dynamic reloc ");
 318       break;
 319     case Arm_reloc_property::RT_PRIVATE:
 320       prefix = _("private reloc ");
 321       break;
 322     case Arm_reloc_property::RT_OBSOLETE:
 323       prefix = _("obsolete reloc ");
 324       break;
 325     default:
 326       gold_unreachable();
 327     }
 328   return std::string(prefix) + arp->name();
 329 }
 330
 331 } // End namespace gold.