gold/arm-reloc-property.cc

   1 // arm-reloc-property.cc -- ARM relocation property.
   2
   3 // Copyright (C) 2010-2023 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     uses_symbol_(false)
 109 {
 110   // Set size and alignment of static and dynamic relocations.
 111   if (rtype == RT_STATIC)
 112     {
 113       switch (rclass)
 114         {
 115         case RC_DATA:
 116           // Except for R_ARM_ABS16 and R_ARM_ABS8, all static data relocations
 117           // have size 4.  All static data relocations have alignment of 1.
 118           if (code == elfcpp::R_ARM_ABS8)
 119             this->size_ = 1;
 120           else if (code == elfcpp::R_ARM_ABS16)
 121             this->size_ = 2;
 122           else
 123             this->size_ = 4;
 124           this->align_ = 1;
 125           break;
 126         case RC_MISC:
 127           // R_ARM_V4BX should be treated as an ARM relocation.  For all
 128           // others, just use defaults.
 129           if (code != elfcpp::R_ARM_V4BX)
 130             break;
 131           // Fall through.
 132         case RC_ARM:
 133           this->size_ = 4;
 134           this->align_ = 4;
 135           break;
 136         case RC_THM16:
 137           this->size_ = 2;
 138           this->align_ = 2;
 139           break;
 140         case RC_THM32:
 141           this->size_ = 4;
 142           this->align_ = 2;
 143           break;
 144         default:
 145           gold_unreachable();
 146         }
 147     }
 148   else if (rtype == RT_DYNAMIC)
 149     {
 150       // With the exception of R_ARM_COPY, all dynamic relocations requires
 151       // that the place being relocated is a word-aligned 32-bit object.
 152       if (code != elfcpp::R_ARM_COPY)
 153         {
 154           this->size_ = 4;
 155           this->align_ = 4;
 156         }
 157     }
 158
 159   // If no relocation operation is specified, we are done.
 160   if (operation == "NONE")
 161     return;
 162
 163   // Extract information from relocation operation.
 164   Tree_node* root_node = Tree_node::make_tree(operation);
 165   Tree_node* node = root_node;
 166
 167   // Check for an expression of the form XXX - YYY.
 168   if (!node->is_leaf()
 169       && node->child(0)->is_leaf()
 170       && node->child(0)->name() == "-")
 171     {
 172       struct RAB_table_entry
 173       {
 174         Relative_address_base rab;
 175         const char* name;
 176       };
 177
 178       static const RAB_table_entry rab_table[] =
 179       {
 180         { RAB_B_S, "( B S )" },
 181         { RAB_DELTA_B_S, "( DELTA_B ( S ) )" },
 182         { RAB_GOT_ORG, "GOT_ORG" },
 183         { RAB_P, "P" },
 184         { RAB_Pa, "Pa" },
 185         { RAB_TLS, "TLS" },
 186         { RAB_tp, "tp" }
 187       };
 188
 189       static size_t rab_table_size = sizeof(rab_table) / sizeof(rab_table[0]);
 190       const std::string rhs(node->child(2)->s_expression());
 191       for (size_t i = 0; i < rab_table_size; ++i)
 192         if (rhs == rab_table[i].name)
 193           {
 194             this->relative_address_base_ = rab_table[i].rab;
 195             break;
 196           }
 197
 198       gold_assert(this->relative_address_base_ != RAB_NONE);
 199       if (this->relative_address_base_ == RAB_B_S)
 200         this->uses_symbol_base_ = true;
 201       node = node->child(1);
 202     }
 203
 204   // Check for an expression of the form XXX | T.
 205   if (!node->is_leaf()
 206       && node->child(0)->is_leaf()
 207       && node->child(0)->name() == "|")
 208     {
 209       gold_assert(node->number_of_children() == 3
 210                   && node->child(2)->is_leaf()
 211                   && node->child(2)->name() == "T");
 212       this->uses_thumb_bit_ = true;
 213       node = node->child(1);
 214     }
 215
 216   // Check for an expression of the form XXX + A.
 217   if (!node->is_leaf()
 218       && node->child(0)->is_leaf()
 219       && node->child(0)->name() == "+")
 220     {
 221       gold_assert(node->number_of_children() == 3
 222                   && node->child(2)->is_leaf()
 223                   && node->child(2)->name() == "A");
 224       this->uses_addend_ = true;
 225       node = node->child(1);
 226     }
 227
 228   // Check for an expression of the form XXX(S).
 229   if (!node->is_leaf() && node->child(0)->is_leaf())
 230     {
 231       gold_assert(node->number_of_children() == 2
 232                   && node->child(1)->is_leaf()
 233                   && node->child(1)->name() == "S");
 234       const std::string func(node->child(0)->name());
 235       if (func == "B")
 236         this->uses_symbol_base_ = true;
 237       else if (func == "GOT")
 238         this->uses_got_entry_ = true;
 239       else if (func == "PLT")
 240         this->uses_plt_entry_ = true;
 241       else if (func == "Module" || func == "DELTA_B")
 242         // These are used in dynamic relocations.
 243         ;
 244       else
 245         gold_unreachable();
 246       node = node->child(1);
 247     }
 248
 249   gold_assert(node->is_leaf() && node->name() == "S");
 250   this->uses_symbol_ = true;
 251
 252   delete root_node;
 253 }
 254
 255 // Arm_reloc_property_table methods.
 256
 257 // Constructor.  This processing informations in arm-reloc.def to
 258 // initialize the table.
 259
 260 Arm_reloc_property_table::Arm_reloc_property_table()
 261 {
 262   // These appear in arm-reloc.def.  Do not rename them.
 263   Parse_expression A("A"), GOT_ORG("GOT_ORG"), NONE("NONE"), P("P"),
 264                    Pa("Pa"), S("S"), T("T"), TLS("TLS"), tp("tp");
 265   const bool Y(true), N(false);
 266
 267   for (unsigned int i = 0; i < Property_table_size; ++i)
 268     this->table_[i] = NULL;
 269
 270 #undef RD
 271 #define RD(name, type, deprecated, class, operation, is_implemented, \
 272            group_index, checks_oveflow) \
 273   do \
 274     { \
 275       unsigned int code = elfcpp::R_ARM_##name; \
 276       gold_assert(code < Property_table_size); \
 277       this->table_[code] = \
 278         new Arm_reloc_property(elfcpp::R_ARM_##name, "R_ARM_" #name, \
 279                                Arm_reloc_property::RT_##type, deprecated, \
 280                                Arm_reloc_property::RC_##class, \
 281                                (operation).s_expression(), is_implemented, \
 282                                group_index, checks_oveflow); \
 283     } \
 284   while(0);
 285
 286 #include "arm-reloc.def"
 287 #undef RD
 288 }
 289
 290 // Return a string describing a relocation code that fails to get a
 291 // relocation property in get_implemented_static_reloc_property().
 292
 293 std::string
 294 Arm_reloc_property_table::reloc_name_in_error_message(unsigned int code)
 295 {
 296   gold_assert(code < Property_table_size);
 297
 298   const Arm_reloc_property* arp = this->table_[code];
 299
 300   if (arp == NULL)
 301     {
 302       char buffer[100];
 303       sprintf(buffer, _("invalid reloc %u"), code);
 304       return std::string(buffer);
 305     }
 306
 307   // gold only implements static relocation codes.
 308   Arm_reloc_property::Reloc_type reloc_type = arp->reloc_type();
 309   gold_assert(reloc_type == Arm_reloc_property::RT_STATIC
 310               || !arp->is_implemented());
 311
 312   const char* prefix = NULL;
 313   switch (reloc_type)
 314     {
 315     case Arm_reloc_property::RT_STATIC:
 316       prefix = arp->is_implemented() ? _("reloc ") : _("unimplemented reloc ");
 317       break;
 318     case Arm_reloc_property::RT_DYNAMIC:
 319       prefix = _("dynamic reloc ");
 320       break;
 321     case Arm_reloc_property::RT_PRIVATE:
 322       prefix = _("private reloc ");
 323       break;
 324     case Arm_reloc_property::RT_OBSOLETE:
 325       prefix = _("obsolete reloc ");
 326       break;
 327     default:
 328       gold_unreachable();
 329     }
 330   return std::string(prefix) + arp->name();
 331 }
 332
 333 } // End namespace gold.