[thirdparty/binutils-gdb.git] / gold / arm-reloc-property.cc

// arm-reloc-property.cc -- ARM relocation property.

// Copyright (C) 2010-2020 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.
Commit	Line	Data
0d31c79d DK	1	// arm-reloc-property.cc -- ARM relocation property.
0d31c79d DK	2
b3adc24a	3	// Copyright (C) 2010-2020 Free Software Foundation, Inc.
0d31c79d DK	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
6cfaf60b	25	#include <cstdio>
0d31c79d DK	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),
b2286c10 DK	107	uses_thumb_bit_(false), uses_symbol_base_(false), uses_addend_(false),
b2286c10 DK	108	uses_symbol_(false)
0d31c79d DK	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");
b2286c10	250	this->uses_symbol_ = true;
0d31c79d DK	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	{
9b547ce6	262	// These appear in arm-reloc.def. Do not rename them.
0d31c79d DK	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
5c57f1be DK	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
0d31c79d	333	} // End namespace gold.