1 // arm-reloc-property.cc -- ARM relocation property. 2 3 // Copyright (C) 2010-2016 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. 334