URL
https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk
Subversion Repositories open8_urisc
[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [gold/] [arm-reloc-property.cc] - Rev 183
Go to most recent revision | Compare with Previous | Blame | View Log
// arm-reloc-property.cc -- ARM relocation property. // Copyright 2010 Free Software Foundation, Inc. // Written by Doug Kwan <dougkwan@google.com>. // This file is part of gold. // This program is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, // MA 02110-1301, USA. #include "gold.h" #include <cstdio> #include <cstring> #include <stack> #include <string> #include <vector> #include "elfcpp.h" #include "arm.h" #include "arm-reloc-property.h" namespace gold { // Arm_reloc_property::Tree_node methods. // Parse an S-expression S and build a tree and return the root node. // Caller is responsible for releasing tree after use. Arm_reloc_property::Tree_node* Arm_reloc_property::Tree_node::make_tree(const std::string& s) { std::stack<size_t> size_stack; Tree_node_vector node_stack; // strtok needs a non-const string pointer. char* buffer = new char[s.size() + 1]; memcpy(buffer, s.data(), s.size()); buffer[s.size()] = '\0'; char* token = strtok(buffer, " "); while (token != NULL) { if (strcmp(token, "(") == 0) // Remember the node stack position for start of a new internal node. size_stack.push(node_stack.size()); else if (strcmp(token, ")") == 0) { // Pop all tree nodes after the previous '(' and use them as // children to build a new internal node. Push internal node back. size_t current_size = node_stack.size(); size_t prev_size = size_stack.top(); size_stack.pop(); Tree_node* node = new Tree_node(node_stack.begin() + prev_size, node_stack.begin() + current_size); node_stack.resize(prev_size); node_stack.push_back(node); } else // Just push a leaf node to node_stack. node_stack.push_back(new Tree_node(token)); token = strtok(NULL, " "); } delete[] buffer; // At this point, size_stack should be empty and node_stack should only // contain the root node. gold_assert(size_stack.empty() && node_stack.size() == 1); return node_stack[0]; } // Arm_reloc_property methods. // Constructor. Arm_reloc_property::Arm_reloc_property( unsigned int code, const char* name, Reloc_type rtype, bool is_deprecated, Reloc_class rclass, const std::string& operation, bool is_implemented, int group_index, bool checks_overflow) : code_(code), name_(name), reloc_type_(rtype), reloc_class_(rclass), group_index_(group_index), size_(0), align_(1), relative_address_base_(RAB_NONE), is_deprecated_(is_deprecated), is_implemented_(is_implemented), checks_overflow_(checks_overflow), uses_got_entry_(false), uses_got_origin_(false), uses_plt_entry_(false), uses_thumb_bit_(false), uses_symbol_base_(false), uses_addend_(false), uses_symbol_(false) { // Set size and alignment of static and dynamic relocations. if (rtype == RT_STATIC) { switch (rclass) { case RC_DATA: // Except for R_ARM_ABS16 and R_ARM_ABS8, all static data relocations // have size 4. All static data relocations have alignment of 1. if (code == elfcpp::R_ARM_ABS8) this->size_ = 1; else if (code == elfcpp::R_ARM_ABS16) this->size_ = 2; else this->size_ = 4; this->align_ = 1; break; case RC_MISC: // R_ARM_V4BX should be treated as an ARM relocation. For all // others, just use defaults. if (code != elfcpp::R_ARM_V4BX) break; // Fall through. case RC_ARM: this->size_ = 4; this->align_ = 4; break; case RC_THM16: this->size_ = 2; this->align_ = 2; break; case RC_THM32: this->size_ = 4; this->align_ = 2; break; default: gold_unreachable(); } } else if (rtype == RT_DYNAMIC) { // With the exception of R_ARM_COPY, all dynamic relocations requires // that the place being relocated is a word-aligned 32-bit object. if (code != elfcpp::R_ARM_COPY) { this->size_ = 4; this->align_ = 4; } } // If no relocation operation is specified, we are done. if (operation == "NONE") return; // Extract information from relocation operation. Tree_node* root_node = Tree_node::make_tree(operation); Tree_node* node = root_node; // Check for an expression of the form XXX - YYY. if (!node->is_leaf() && node->child(0)->is_leaf() && node->child(0)->name() == "-") { struct RAB_table_entry { Relative_address_base rab; const char* name; }; static const RAB_table_entry rab_table[] = { { RAB_B_S, "( B S )" }, { RAB_DELTA_B_S, "( DELTA_B ( S ) )" }, { RAB_GOT_ORG, "GOT_ORG" }, { RAB_P, "P" }, { RAB_Pa, "Pa" }, { RAB_TLS, "TLS" }, { RAB_tp, "tp" } }; static size_t rab_table_size = sizeof(rab_table) / sizeof(rab_table[0]); const std::string rhs(node->child(2)->s_expression()); for (size_t i = 0; i < rab_table_size; ++i) if (rhs == rab_table[i].name) { this->relative_address_base_ = rab_table[i].rab; break; } gold_assert(this->relative_address_base_ != RAB_NONE); if (this->relative_address_base_ == RAB_B_S) this->uses_symbol_base_ = true; node = node->child(1); } // Check for an expression of the form XXX | T. if (!node->is_leaf() && node->child(0)->is_leaf() && node->child(0)->name() == "|") { gold_assert(node->number_of_children() == 3 && node->child(2)->is_leaf() && node->child(2)->name() == "T"); this->uses_thumb_bit_ = true; node = node->child(1); } // Check for an expression of the form XXX + A. if (!node->is_leaf() && node->child(0)->is_leaf() && node->child(0)->name() == "+") { gold_assert(node->number_of_children() == 3 && node->child(2)->is_leaf() && node->child(2)->name() == "A"); this->uses_addend_ = true; node = node->child(1); } // Check for an expression of the form XXX(S). if (!node->is_leaf() && node->child(0)->is_leaf()) { gold_assert(node->number_of_children() == 2 && node->child(1)->is_leaf() && node->child(1)->name() == "S"); const std::string func(node->child(0)->name()); if (func == "B") this->uses_symbol_base_ = true; else if (func == "GOT") this->uses_got_entry_ = true; else if (func == "PLT") this->uses_plt_entry_ = true; else if (func == "Module" || func == "DELTA_B") // These are used in dynamic relocations. ; else gold_unreachable(); node = node->child(1); } gold_assert(node->is_leaf() && node->name() == "S"); this->uses_symbol_ = true; delete root_node; } // Arm_reloc_property_table methods. // Constructor. This processing informations in arm-reloc.def to // initialize the table. Arm_reloc_property_table::Arm_reloc_property_table() { // These appear in arm-reloc.def. Do not rename them. Parse_expression A("A"), GOT_ORG("GOT_ORG"), NONE("NONE"), P("P"), Pa("Pa"), S("S"), T("T"), TLS("TLS"), tp("tp"); const bool Y(true), N(false); for (unsigned int i = 0; i < Property_table_size; ++i) this->table_[i] = NULL; #undef RD #define RD(name, type, deprecated, class, operation, is_implemented, \ group_index, checks_oveflow) \ do \ { \ unsigned int code = elfcpp::R_ARM_##name; \ gold_assert(code < Property_table_size); \ this->table_[code] = \ new Arm_reloc_property(elfcpp::R_ARM_##name, "R_ARM_" #name, \ Arm_reloc_property::RT_##type, deprecated, \ Arm_reloc_property::RC_##class, \ (operation).s_expression(), is_implemented, \ group_index, checks_oveflow); \ } \ while(0); #include "arm-reloc.def" #undef RD } // Return a string describing a relocation code that fails to get a // relocation property in get_implemented_static_reloc_property(). std::string Arm_reloc_property_table::reloc_name_in_error_message(unsigned int code) { gold_assert(code < Property_table_size); const Arm_reloc_property* arp = this->table_[code]; if (arp == NULL) { char buffer[100]; sprintf(buffer, _("invalid reloc %u"), code); return std::string(buffer); } // gold only implements static relocation codes. Arm_reloc_property::Reloc_type reloc_type = arp->reloc_type(); gold_assert(reloc_type == Arm_reloc_property::RT_STATIC || !arp->is_implemented()); const char* prefix = NULL; switch (reloc_type) { case Arm_reloc_property::RT_STATIC: prefix = arp->is_implemented() ? _("reloc ") : _("unimplemented reloc "); break; case Arm_reloc_property::RT_DYNAMIC: prefix = _("dynamic reloc "); break; case Arm_reloc_property::RT_PRIVATE: prefix = _("private reloc "); break; case Arm_reloc_property::RT_OBSOLETE: prefix = _("obsolete reloc "); break; default: gold_unreachable(); } return std::string(prefix) + arp->name(); } } // End namespace gold.
Go to most recent revision | Compare with Previous | Blame | View Log