[deliverable/binutils-gdb.git] / bfd / arc-got.h

/* ARC-specific support for 32-bit ELF
   Copyright (C) 1994-2019 Free Software Foundation, Inc.
   Contributed by Cupertino Miranda (cmiranda@synopsys.com).

   This file is part of BFD, the Binary File Descriptor library.

   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.  */

#ifndef ARC_GOT_H
#define ARC_GOT_H

#define TCB_SIZE (8)

#define	align_power(addr, align)	\
  (((addr) + ((bfd_vma) 1 << (align)) - 1) & (-((bfd_vma) 1 << (align))))

enum tls_type_e
{
  GOT_UNKNOWN = 0,
  GOT_NORMAL,
  GOT_TLS_GD,
  GOT_TLS_IE,
  GOT_TLS_LE
};

enum tls_got_entries
{
  TLS_GOT_NONE = 0,
  TLS_GOT_MOD,
  TLS_GOT_OFF,
  TLS_GOT_MOD_AND_OFF
};

struct got_entry
{
  struct got_entry *next;
  enum tls_type_e type;
  bfd_vma offset;
  bfd_boolean processed;
  bfd_boolean created_dyn_relocation;
  enum tls_got_entries existing_entries;
};

/* Return the local got list, if not defined, create an empty one.  */

static struct got_entry **
arc_get_local_got_ents (bfd * abfd)
{
  if (elf_local_got_ents (abfd) == NULL)
    {
      bfd_size_type amt = (elf_tdata (abfd)->symtab_hdr.sh_info
			   * sizeof (*elf_local_got_ents (abfd)));
      elf_local_got_ents (abfd) = bfd_zmalloc (amt);
      if (elf_local_got_ents (abfd) == NULL)
	{
	  _bfd_error_handler (_("%pB: cannot allocate memory for local "
				"GOT entries"), abfd);
	  bfd_set_error (bfd_error_bad_value);
	  return NULL;
	}
    }

  return elf_local_got_ents (abfd);
}

static struct got_entry *
got_entry_for_type (struct got_entry **list,
		    enum tls_type_e type)
{
  struct got_entry **p = list;

  while (*p != NULL)
    {
      if ((*p)->type == type)
	return *p;
      p = &((*p)->next);
    }
  return NULL;
}

static void
new_got_entry_to_list (struct got_entry **list,
		       enum tls_type_e type,
		       bfd_vma offset,
		       enum tls_got_entries existing_entries)
{
  /* Find list end.  Avoid having multiple entries of the same
     type.  */
  struct got_entry **p = list;
  struct got_entry *entry;

  while (*p != NULL)
    {
      if ((*p)->type == type)
	return;
      p = &((*p)->next);
    }

  entry = (struct got_entry *) xmalloc (sizeof (struct got_entry));

  entry->type = type;
  entry->offset = offset;
  entry->next = NULL;
  entry->processed = FALSE;
  entry->created_dyn_relocation = FALSE;
  entry->existing_entries = existing_entries;

  ARC_DEBUG ("New GOT got entry added to list: "
	     "type: %d, offset: %ld, existing_entries: %d\n",
	     type, (long) offset, existing_entries);

  /* Add the entry to the end of the list.  */
  *p = entry;
}

static enum tls_type_e
tls_type_for_reloc (reloc_howto_type *howto)
{
  enum tls_type_e ret = GOT_UNKNOWN;

  if (is_reloc_for_GOT (howto))
    return GOT_NORMAL;

  switch (howto->type)
    {
    case R_ARC_TLS_GD_GOT:
      ret = GOT_TLS_GD;
      break;
    case R_ARC_TLS_IE_GOT:
      ret = GOT_TLS_IE;
      break;
    case R_ARC_TLS_LE_32:
      ret = GOT_TLS_LE;
      break;
    default:
      ret = GOT_UNKNOWN;
      break;
    }

  return ret;
};

static struct got_entry **
get_got_entry_list_for_symbol (bfd *abfd,
			       unsigned long r_symndx,
			       struct elf_link_hash_entry *h)
{
  struct elf_arc_link_hash_entry *h1 =
    ((struct elf_arc_link_hash_entry *) h);
  if (h1 != NULL)
    {
      return &h1->got_ents;
    }
  else
    {
      return arc_get_local_got_ents (abfd) + r_symndx;
    }
}


static enum tls_type_e
arc_got_entry_type_for_reloc (reloc_howto_type *howto)
{
  enum tls_type_e type = GOT_UNKNOWN;

  if (is_reloc_for_GOT (howto))
    return  GOT_NORMAL;

  if (is_reloc_for_TLS (howto))
    {
      switch (howto->type)
	{
	  case R_ARC_TLS_GD_GOT:
	    type = GOT_TLS_GD;
	    break;
	  case R_ARC_TLS_IE_GOT:
	    type = GOT_TLS_IE;
	    break;
	  default:
	    break;
	}
    }
  return type;
}

#define ADD_SYMBOL_REF_SEC_AND_RELOC(SECNAME, COND_FOR_RELOC, H)	\
  htab->s##SECNAME->size;						\
  {									\
    if (COND_FOR_RELOC)							\
      {									\
	htab->srel##SECNAME->size += sizeof (Elf32_External_Rela);	\
	  ARC_DEBUG ("arc_info: Added reloc space in "			\
		     #SECNAME " section at " __FILE__			\
		     ":%d for symbol %s\n",				\
		     __LINE__, name_for_global_symbol (H));		\
      }									\
    if (H)								\
      if (H->dynindx == -1 && !H->forced_local)				\
	if (! bfd_elf_link_record_dynamic_symbol (info, H))		\
	  return FALSE;							\
     htab->s##SECNAME->size += 4;					\
   }									\

static bfd_boolean
arc_fill_got_info_for_reloc (enum tls_type_e type,
			     struct got_entry **list,
			     struct bfd_link_info *  info,
			     struct elf_link_hash_entry *h)
{
  struct elf_link_hash_table *htab = elf_hash_table (info);

  if (got_entry_for_type (list, type) != NULL)
    return TRUE;

  switch (type)
    {
      case GOT_NORMAL:
	{
	  bfd_vma offset
	    = ADD_SYMBOL_REF_SEC_AND_RELOC (got, bfd_link_pic (info)
						 || h != NULL, h);
	  new_got_entry_to_list (list, type, offset, TLS_GOT_NONE);
	}
	break;


      case GOT_TLS_GD:
	{
	  bfd_vma offset
	    = ADD_SYMBOL_REF_SEC_AND_RELOC (got, TRUE, h);
	  bfd_vma ATTRIBUTE_UNUSED notneeded
	    = ADD_SYMBOL_REF_SEC_AND_RELOC (got, TRUE, h);
	  new_got_entry_to_list (list, type, offset, TLS_GOT_MOD_AND_OFF);
	}
	break;
      case GOT_TLS_IE:
      case GOT_TLS_LE:
	{
	  bfd_vma offset
	    = ADD_SYMBOL_REF_SEC_AND_RELOC (got, TRUE, h);
	  new_got_entry_to_list (list, type, offset, TLS_GOT_OFF);
	}
	break;

      default:
	return FALSE;
	break;
    }
  return TRUE;
}


static bfd_vma
relocate_fix_got_relocs_for_got_info (struct got_entry **	   list_p,
				      enum tls_type_e		   type,
				      struct bfd_link_info *	   info,
				      bfd *			   output_bfd,
				      unsigned long		   r_symndx,
				      Elf_Internal_Sym *	   local_syms,
				      asection **		   local_sections,
				      struct elf_link_hash_entry * h,
				      struct arc_relocation_data * reloc_data)
{
  struct elf_link_hash_table *htab = elf_hash_table (info);
  struct got_entry *entry = NULL;

  if (list_p == NULL || type == GOT_UNKNOWN || type == GOT_TLS_LE)
    return 0;

  entry = got_entry_for_type (list_p, type);
  BFD_ASSERT (entry);

  if (h == NULL
      || h->forced_local == TRUE
      || (! elf_hash_table (info)->dynamic_sections_created
	  || (bfd_link_pic (info)
	      && SYMBOL_REFERENCES_LOCAL (info, h))))
    {
      const char ATTRIBUTE_UNUSED *symbol_name;
      static const char local_name[] = "(local)";
      asection *tls_sec = NULL;
      bfd_vma sym_value = 0;

      if (h != NULL)
	{
	  // TODO: This should not be here.
	  reloc_data->sym_value = h->root.u.def.value;
	  reloc_data->sym_section = h->root.u.def.section;

	  sym_value = h->root.u.def.value
	    + h->root.u.def.section->output_section->vma
	    + h->root.u.def.section->output_offset;

	  tls_sec = elf_hash_table (info)->tls_sec;

	  symbol_name = h->root.root.string;
	}
      else
	{
	  Elf_Internal_Sym *sym = local_syms + r_symndx;
	  asection *sec = local_sections[r_symndx];

	  sym_value = sym->st_value
	    + sec->output_section->vma
	    + sec->output_offset;

	  tls_sec = elf_hash_table (info)->tls_sec;

	  symbol_name = local_name;
	}


      if (entry && !entry->processed)
	{
	  switch (entry->type)
	    {
	    case GOT_TLS_GD:
	      {
		BFD_ASSERT (tls_sec && tls_sec->output_section);
		bfd_vma sec_vma = tls_sec->output_section->vma;

		if (h == NULL || h->forced_local
		   || !elf_hash_table (info)->dynamic_sections_created)
		  {
		    bfd_put_32 (output_bfd,
			    sym_value - sec_vma
			    + (elf_hash_table (info)->dynamic_sections_created
			       ? 0
			       : (align_power (0,
					       tls_sec->alignment_power))),
			    htab->sgot->contents + entry->offset
			    + (entry->existing_entries == TLS_GOT_MOD_AND_OFF
			       ? 4 : 0));

		    ARC_DEBUG ("arc_info: FIXED -> %s value = %#lx "
			  "@ %lx, for symbol %s\n",
			  (entry->type == GOT_TLS_GD ? "GOT_TLS_GD" :
			   "GOT_TLS_IE"),
			  (long) (sym_value - sec_vma),
			  (long) (htab->sgot->output_section->vma
			     + htab->sgot->output_offset
			     + entry->offset
			     + (entry->existing_entries == TLS_GOT_MOD_AND_OFF
				? 4 : 0)),
			  symbol_name);
		  }
	      }
	      break;

	    case GOT_TLS_IE:
	      {
		BFD_ASSERT (tls_sec && tls_sec->output_section);
		bfd_vma ATTRIBUTE_UNUSED sec_vma
		  = tls_sec->output_section->vma;

		bfd_put_32 (output_bfd,
			    sym_value - sec_vma
			    + (elf_hash_table (info)->dynamic_sections_created
			       ? 0
			       : (align_power (TCB_SIZE,
					       tls_sec->alignment_power))),
			    htab->sgot->contents + entry->offset
			    + (entry->existing_entries == TLS_GOT_MOD_AND_OFF
			       ? 4 : 0));

		ARC_DEBUG ("arc_info: FIXED -> %s value = %#lx "
			   "@ %p, for symbol %s\n",
			   (entry->type == GOT_TLS_GD ? "GOT_TLS_GD" :
			    "GOT_TLS_IE"),
			   (long) (sym_value - sec_vma),
			   (long) (htab->sgot->output_section->vma
			      + htab->sgot->output_offset
			      + entry->offset
			      + (entry->existing_entries == TLS_GOT_MOD_AND_OFF
				 ? 4 : 0)),
			   symbol_name);
	      }
	      break;

	    case GOT_NORMAL:
	      {
		bfd_vma sec_vma
		  = reloc_data->sym_section->output_section->vma
		  + reloc_data->sym_section->output_offset;

		if (h != NULL
		    && h->root.type == bfd_link_hash_undefweak)
		  ARC_DEBUG ("arc_info: PATCHED: NOT_PATCHED "
			     "@ %#08lx for sym %s in got offset %#lx "
			     "(is undefweak)\n",
			     (long) (htab->sgot->output_section->vma
				     + htab->sgot->output_offset
				     + entry->offset),
			     symbol_name,
			     (long) entry->offset);
		else
		  {
		    bfd_put_32 (output_bfd,
				reloc_data->sym_value + sec_vma,
				htab->sgot->contents + entry->offset);
		    ARC_DEBUG ("arc_info: PATCHED: %#08lx "
			       "@ %#08lx for sym %s in got offset %#lx\n",
			       (long) (reloc_data->sym_value + sec_vma),
			       (long) (htab->sgot->output_section->vma
				       + htab->sgot->output_offset + entry->offset),
			       symbol_name,
			       (long) entry->offset);
		  }
	      }
	      break;
	    default:
	      BFD_ASSERT (0);
	      break;
	    }
	  entry->processed = TRUE;
	}
    }

  return entry->offset;
}

static void
create_got_dynrelocs_for_single_entry (struct got_entry *list,
				       bfd *output_bfd,
				       struct bfd_link_info *  info,
				       struct elf_link_hash_entry *h)
{
  if (list == NULL)
    return;

  bfd_vma got_offset = list->offset;

  if (list->type == GOT_NORMAL
      && !list->created_dyn_relocation)
    {
      if (bfd_link_pic (info)
	  && h != NULL
	      && (info->symbolic || h->dynindx == -1)
	      && h->def_regular)
	{
	  ADD_RELA (output_bfd, got, got_offset, 0, R_ARC_RELATIVE, 0);
	}
      /* Do not fully understand the side effects of this condition.
	 The relocation space might still being reserved.  Perhaps
	 I should clear its value.  */
      else if (h != NULL && h->dynindx != -1)
	{
	  ADD_RELA (output_bfd, got, got_offset, h->dynindx, R_ARC_GLOB_DAT, 0);
	}
      list->created_dyn_relocation = TRUE;
    }
  else if (list->existing_entries != TLS_GOT_NONE
	   && !list->created_dyn_relocation)
    {
       /* TODO TLS: This is not called for local symbols.
	  In order to correctly implement TLS, this should also
	  be called for all local symbols with tls got entries.
	  Should be moved to relocate_section in order to make it
	  work for local symbols.  */
      struct elf_link_hash_table *htab = elf_hash_table (info);
      enum tls_got_entries e = list->existing_entries;

      BFD_ASSERT (list->type != GOT_TLS_GD
		  || list->existing_entries == TLS_GOT_MOD_AND_OFF);

      bfd_vma dynindx = (h == NULL || h->dynindx == -1) ? 0 : h->dynindx;

      if (e == TLS_GOT_MOD_AND_OFF || e == TLS_GOT_MOD)
	{
	      ADD_RELA (output_bfd, got, got_offset, dynindx,
			R_ARC_TLS_DTPMOD, 0);
	      ARC_DEBUG ("arc_info: TLS_DYNRELOC: type = %d, \
GOT_OFFSET = %#lx, GOT_VMA = %#lx, INDEX = %ld, ADDEND = 0x0\n",
			 list->type,
			 (long) got_offset,
			 (long) (htab->sgot->output_section->vma
				 + htab->sgot->output_offset + got_offset),
			 (long) dynindx);
	}

      if (e == TLS_GOT_MOD_AND_OFF || e == TLS_GOT_OFF)
	{
	  bfd_vma addend = 0;
	  if (list->type == GOT_TLS_IE)
	  {
	    addend = bfd_get_32 (output_bfd,
				 htab->sgot->contents + got_offset);
	  }

	  ADD_RELA (output_bfd, got,
		    got_offset + (e == TLS_GOT_MOD_AND_OFF ? 4 : 0),
		    dynindx,
		    (list->type == GOT_TLS_IE ? R_ARC_TLS_TPOFF
					      : R_ARC_TLS_DTPOFF),
		    addend);

	  ARC_DEBUG ("arc_info: TLS_DYNRELOC: type = %d, \
GOT_OFFSET = %#lx, GOT_VMA = %#lx, INDEX = %ld, ADDEND = %#lx\n",
		     list->type,
		     (long) got_offset,
		     (long) (htab->sgot->output_section->vma
			     + htab->sgot->output_offset + got_offset),
		     (long) dynindx, (long) addend);
	}
      list->created_dyn_relocation = TRUE;
    }
}

static void
create_got_dynrelocs_for_got_info (struct got_entry **list_p,
				   bfd *output_bfd,
				   struct bfd_link_info *  info,
				   struct elf_link_hash_entry *h)
{
  if (list_p == NULL)
    return;

  struct got_entry *list = *list_p;
  /* Traverse the list of got entries for this symbol.  */
  while (list)
    {
      create_got_dynrelocs_for_single_entry (list, output_bfd, info, h);
      list = list->next;
    }
}

#undef ADD_SYMBOL_REF_SEC_AND_RELOC

#endif /* ARC_GOT_H */
Commit	Line	Data
08759e0f	1	/* ARC-specific support for 32-bit ELF
82704155	2	Copyright (C) 1994-2019 Free Software Foundation, Inc.
08759e0f CM	3	Contributed by Cupertino Miranda (cmiranda@synopsys.com).
	4
	5	This file is part of BFD, the Binary File Descriptor library.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 3 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
	20	MA 02110-1301, USA. */
	21
	22	#ifndef ARC_GOT_H
	23	#define ARC_GOT_H
	24
a0abe743 CM	25	#define TCB_SIZE (8)
a0abe743 CM	26
0411fca5 CM	27	#define align_power(addr, align) \
	28	(((addr) + ((bfd_vma) 1 << (align)) - 1) & (-((bfd_vma) 1 << (align))))
	29
08759e0f CM	30	enum tls_type_e
	31	{
	32	GOT_UNKNOWN = 0,
	33	GOT_NORMAL,
	34	GOT_TLS_GD,
	35	GOT_TLS_IE,
	36	GOT_TLS_LE
	37	};
	38
	39	enum tls_got_entries
	40	{
	41	TLS_GOT_NONE = 0,
	42	TLS_GOT_MOD,
	43	TLS_GOT_OFF,
	44	TLS_GOT_MOD_AND_OFF
	45	};
	46
	47	struct got_entry
	48	{
	49	struct got_entry *next;
	50	enum tls_type_e type;
	51	bfd_vma offset;
	52	bfd_boolean processed;
	53	bfd_boolean created_dyn_relocation;
	54	enum tls_got_entries existing_entries;
	55	};
	56
0f206410 CZ	57	/* Return the local got list, if not defined, create an empty one. */
0f206410 CZ	58
08759e0f CM	59	static struct got_entry **
	60	arc_get_local_got_ents (bfd * abfd)
	61	{
0f206410	62	if (elf_local_got_ents (abfd) == NULL)
08759e0f	63	{
0f206410 CZ	64	bfd_size_type amt = (elf_tdata (abfd)->symtab_hdr.sh_info
	65	* sizeof (*elf_local_got_ents (abfd)));
	66	elf_local_got_ents (abfd) = bfd_zmalloc (amt);
	67	if (elf_local_got_ents (abfd) == NULL)
	68	{
	69	_bfd_error_handler (_("%pB: cannot allocate memory for local "
	70	"GOT entries"), abfd);
	71	bfd_set_error (bfd_error_bad_value);
	72	return NULL;
	73	}
08759e0f CM	74	}
08759e0f CM	75
0f206410	76	return elf_local_got_ents (abfd);
08759e0f CM	77	}
	78
	79	static struct got_entry *
	80	got_entry_for_type (struct got_entry **list,
	81	enum tls_type_e type)
	82	{
	83	struct got_entry **p = list;
f7e8b360	84
08759e0f CM	85	while (*p != NULL)
	86	{
	87	if ((*p)->type == type)
	88	return *p;
	89	p = &((*p)->next);
	90	}
	91	return NULL;
	92	}
	93
	94	static void
	95	new_got_entry_to_list (struct got_entry **list,
	96	enum tls_type_e type,
	97	bfd_vma offset,
	98	enum tls_got_entries existing_entries)
	99	{
	100	/* Find list end. Avoid having multiple entries of the same
	101	type. */
	102	struct got_entry **p = list;
f7e8b360 NC	103	struct got_entry *entry;
f7e8b360 NC	104
08759e0f CM	105	while (*p != NULL)
	106	{
	107	if ((*p)->type == type)
	108	return;
	109	p = &((*p)->next);
	110	}
	111
f7e8b360	112	entry = (struct got_entry *) xmalloc (sizeof (struct got_entry));
08759e0f CM	113
	114	entry->type = type;
	115	entry->offset = offset;
	116	entry->next = NULL;
	117	entry->processed = FALSE;
	118	entry->created_dyn_relocation = FALSE;
	119	entry->existing_entries = existing_entries;
	120
	121	ARC_DEBUG ("New GOT got entry added to list: "
f7e8b360 NC	122	"type: %d, offset: %ld, existing_entries: %d\n",
f7e8b360 NC	123	type, (long) offset, existing_entries);
08759e0f CM	124
	125	/* Add the entry to the end of the list. */
	126	*p = entry;
	127	}
	128
	129	static enum tls_type_e
	130	tls_type_for_reloc (reloc_howto_type *howto)
	131	{
	132	enum tls_type_e ret = GOT_UNKNOWN;
f7e8b360	133
08759e0f	134	if (is_reloc_for_GOT (howto))
f7e8b360 NC	135	return GOT_NORMAL;
	136
	137	switch (howto->type)
08759e0f	138	{
f7e8b360 NC	139	case R_ARC_TLS_GD_GOT:
	140	ret = GOT_TLS_GD;
	141	break;
	142	case R_ARC_TLS_IE_GOT:
	143	ret = GOT_TLS_IE;
	144	break;
	145	case R_ARC_TLS_LE_32:
	146	ret = GOT_TLS_LE;
	147	break;
	148	default:
	149	ret = GOT_UNKNOWN;
	150	break;
08759e0f	151	}
f7e8b360	152
08759e0f CM	153	return ret;
	154	};
	155
	156	static struct got_entry **
	157	get_got_entry_list_for_symbol (bfd *abfd,
	158	unsigned long r_symndx,
	159	struct elf_link_hash_entry *h)
	160	{
854b8506 CM	161	struct elf_arc_link_hash_entry *h1 =
	162	((struct elf_arc_link_hash_entry *) h);
	163	if (h1 != NULL)
08759e0f	164	{
854b8506	165	return &h1->got_ents;
08759e0f CM	166	}
	167	else
	168	{
0f206410	169	return arc_get_local_got_ents (abfd) + r_symndx;
08759e0f CM	170	}
	171	}
	172
	173
	174	static enum tls_type_e
	175	arc_got_entry_type_for_reloc (reloc_howto_type *howto)
	176	{
	177	enum tls_type_e type = GOT_UNKNOWN;
	178
	179	if (is_reloc_for_GOT (howto))
f7e8b360 NC	180	return GOT_NORMAL;
	181
	182	if (is_reloc_for_TLS (howto))
08759e0f CM	183	{
	184	switch (howto->type)
	185	{
	186	case R_ARC_TLS_GD_GOT:
	187	type = GOT_TLS_GD;
	188	break;
	189	case R_ARC_TLS_IE_GOT:
	190	type = GOT_TLS_IE;
	191	break;
	192	default:
	193	break;
	194	}
	195	}
	196	return type;
	197	}
	198
	199	#define ADD_SYMBOL_REF_SEC_AND_RELOC(SECNAME, COND_FOR_RELOC, H) \
	200	htab->s##SECNAME->size; \
	201	{ \
	202	if (COND_FOR_RELOC) \
	203	{ \
	204	htab->srel##SECNAME->size += sizeof (Elf32_External_Rela); \
	205	ARC_DEBUG ("arc_info: Added reloc space in " \
	206	#SECNAME " section at " __FILE__ \
	207	":%d for symbol %s\n", \
	208	__LINE__, name_for_global_symbol (H)); \
	209	} \
	210	if (H) \
d07b621f	211	if (H->dynindx == -1 && !H->forced_local) \
08759e0f CM	212	if (! bfd_elf_link_record_dynamic_symbol (info, H)) \
	213	return FALSE; \
	214	htab->s##SECNAME->size += 4; \
	215	} \
	216
	217	static bfd_boolean
	218	arc_fill_got_info_for_reloc (enum tls_type_e type,
	219	struct got_entry **list,
	220	struct bfd_link_info * info,
	221	struct elf_link_hash_entry *h)
	222	{
	223	struct elf_link_hash_table *htab = elf_hash_table (info);
	224
	225	if (got_entry_for_type (list, type) != NULL)
	226	return TRUE;
	227
	228	switch (type)
	229	{
	230	case GOT_NORMAL:
	231	{
07d6d2b8	232	bfd_vma offset
08759e0f CM	233	= ADD_SYMBOL_REF_SEC_AND_RELOC (got, bfd_link_pic (info)
08759e0f CM	234	\|\| h != NULL, h);
07d6d2b8	235	new_got_entry_to_list (list, type, offset, TLS_GOT_NONE);
08759e0f CM	236	}
	237	break;
	238
	239
	240	case GOT_TLS_GD:
	241	{
	242	bfd_vma offset
	243	= ADD_SYMBOL_REF_SEC_AND_RELOC (got, TRUE, h);
	244	bfd_vma ATTRIBUTE_UNUSED notneeded
	245	= ADD_SYMBOL_REF_SEC_AND_RELOC (got, TRUE, h);
	246	new_got_entry_to_list (list, type, offset, TLS_GOT_MOD_AND_OFF);
	247	}
	248	break;
	249	case GOT_TLS_IE:
	250	case GOT_TLS_LE:
	251	{
	252	bfd_vma offset
	253	= ADD_SYMBOL_REF_SEC_AND_RELOC (got, TRUE, h);
	254	new_got_entry_to_list (list, type, offset, TLS_GOT_OFF);
	255	}
	256	break;
	257
	258	default:
	259	return FALSE;
	260	break;
	261	}
	262	return TRUE;
	263	}
	264
	265
	266	static bfd_vma
07d6d2b8 AM	267	relocate_fix_got_relocs_for_got_info (struct got_entry ** list_p,
	268	enum tls_type_e type,
	269	struct bfd_link_info * info,
	270	bfd * output_bfd,
	271	unsigned long r_symndx,
	272	Elf_Internal_Sym * local_syms,
	273	asection ** local_sections,
	274	struct elf_link_hash_entry * h,
f7e8b360	275	struct arc_relocation_data * reloc_data)
08759e0f	276	{
f7e8b360 NC	277	struct elf_link_hash_table *htab = elf_hash_table (info);
f7e8b360 NC	278	struct got_entry *entry = NULL;
08759e0f CM	279
	280	if (list_p == NULL \|\| type == GOT_UNKNOWN \|\| type == GOT_TLS_LE)
	281	return 0;
	282
08759e0f CM	283	entry = got_entry_for_type (list_p, type);
	284	BFD_ASSERT (entry);
	285
	286	if (h == NULL
d07b621f	287	\|\| h->forced_local == TRUE
08759e0f CM	288	\|\| (! elf_hash_table (info)->dynamic_sections_created
08759e0f CM	289	\|\| (bfd_link_pic (info)
f7e8b360	290	&& SYMBOL_REFERENCES_LOCAL (info, h))))
08759e0f CM	291	{
	292	const char ATTRIBUTE_UNUSED *symbol_name;
	293	static const char local_name[] = "(local)";
	294	asection *tls_sec = NULL;
	295	bfd_vma sym_value = 0;
	296
	297	if (h != NULL)
	298	{
	299	// TODO: This should not be here.
	300	reloc_data->sym_value = h->root.u.def.value;
	301	reloc_data->sym_section = h->root.u.def.section;
	302
	303	sym_value = h->root.u.def.value
f7e8b360 NC	304	+ h->root.u.def.section->output_section->vma
f7e8b360 NC	305	+ h->root.u.def.section->output_offset;
08759e0f CM	306
	307	tls_sec = elf_hash_table (info)->tls_sec;
	308
	309	symbol_name = h->root.root.string;
	310	}
	311	else
	312	{
	313	Elf_Internal_Sym *sym = local_syms + r_symndx;
	314	asection *sec = local_sections[r_symndx];
	315
	316	sym_value = sym->st_value
f7e8b360 NC	317	+ sec->output_section->vma
f7e8b360 NC	318	+ sec->output_offset;
08759e0f CM	319
	320	tls_sec = elf_hash_table (info)->tls_sec;
	321
	322	symbol_name = local_name;
	323	}
	324
	325
535b785f	326	if (entry && !entry->processed)
08759e0f CM	327	{
	328	switch (entry->type)
	329	{
f7e8b360 NC	330	case GOT_TLS_GD:
	331	{
	332	BFD_ASSERT (tls_sec && tls_sec->output_section);
	333	bfd_vma sec_vma = tls_sec->output_section->vma;
	334
d07b621f CM	335	if (h == NULL \|\| h->forced_local
	336	\|\| !elf_hash_table (info)->dynamic_sections_created)
	337	{
	338	bfd_put_32 (output_bfd,
714e9a95 CM	339	sym_value - sec_vma
	340	+ (elf_hash_table (info)->dynamic_sections_created
	341	? 0
d07b621f	342	: (align_power (0,
714e9a95	343	tls_sec->alignment_power))),
f7e8b360 NC	344	htab->sgot->contents + entry->offset
	345	+ (entry->existing_entries == TLS_GOT_MOD_AND_OFF
	346	? 4 : 0));
	347
d07b621f CM	348	ARC_DEBUG ("arc_info: FIXED -> %s value = %#lx "
	349	"@ %lx, for symbol %s\n",
	350	(entry->type == GOT_TLS_GD ? "GOT_TLS_GD" :
	351	"GOT_TLS_IE"),
	352	(long) (sym_value - sec_vma),
	353	(long) (htab->sgot->output_section->vma
	354	+ htab->sgot->output_offset
	355	+ entry->offset
	356	+ (entry->existing_entries == TLS_GOT_MOD_AND_OFF
	357	? 4 : 0)),
	358	symbol_name);
	359	}
f7e8b360 NC	360	}
	361	break;
	362
	363	case GOT_TLS_IE:
	364	{
	365	BFD_ASSERT (tls_sec && tls_sec->output_section);
	366	bfd_vma ATTRIBUTE_UNUSED sec_vma
	367	= tls_sec->output_section->vma;
	368
4dd72ffd	369	bfd_put_32 (output_bfd,
a0abe743	370	sym_value - sec_vma
0411fca5 CM	371	+ (elf_hash_table (info)->dynamic_sections_created
	372	? 0
	373	: (align_power (TCB_SIZE,
	374	tls_sec->alignment_power))),
4dd72ffd CM	375	htab->sgot->contents + entry->offset
	376	+ (entry->existing_entries == TLS_GOT_MOD_AND_OFF
	377	? 4 : 0));
	378
f7e8b360 NC	379	ARC_DEBUG ("arc_info: FIXED -> %s value = %#lx "
	380	"@ %p, for symbol %s\n",
	381	(entry->type == GOT_TLS_GD ? "GOT_TLS_GD" :
	382	"GOT_TLS_IE"),
	383	(long) (sym_value - sec_vma),
4dd72ffd	384	(long) (htab->sgot->output_section->vma
714e9a95	385	+ htab->sgot->output_offset
4dd72ffd CM	386	+ entry->offset
	387	+ (entry->existing_entries == TLS_GOT_MOD_AND_OFF
	388	? 4 : 0)),
f7e8b360 NC	389	symbol_name);
	390	}
	391	break;
	392
	393	case GOT_NORMAL:
	394	{
	395	bfd_vma sec_vma
	396	= reloc_data->sym_section->output_section->vma
	397	+ reloc_data->sym_section->output_offset;
	398
c02d11a5 CM	399	if (h != NULL
	400	&& h->root.type == bfd_link_hash_undefweak)
	401	ARC_DEBUG ("arc_info: PATCHED: NOT_PATCHED "
	402	"@ %#08lx for sym %s in got offset %#lx "
	403	"(is undefweak)\n",
	404	(long) (htab->sgot->output_section->vma
	405	+ htab->sgot->output_offset
	406	+ entry->offset),
	407	symbol_name,
	408	(long) entry->offset);
	409	else
f7e8b360 NC	410	{
	411	bfd_put_32 (output_bfd,
	412	reloc_data->sym_value + sec_vma,
	413	htab->sgot->contents + entry->offset);
f7e8b360 NC	414	ARC_DEBUG ("arc_info: PATCHED: %#08lx "
	415	"@ %#08lx for sym %s in got offset %#lx\n",
	416	(long) (reloc_data->sym_value + sec_vma),
	417	(long) (htab->sgot->output_section->vma
	418	+ htab->sgot->output_offset + entry->offset),
	419	symbol_name,
	420	(long) entry->offset);
	421	}
f7e8b360 NC	422	}
	423	break;
	424	default:
	425	BFD_ASSERT (0);
	426	break;
08759e0f CM	427	}
	428	entry->processed = TRUE;
	429	}
	430	}
	431
	432	return entry->offset;
	433	}
	434
	435	static void
	436	create_got_dynrelocs_for_single_entry (struct got_entry *list,
	437	bfd *output_bfd,
	438	struct bfd_link_info * info,
	439	struct elf_link_hash_entry *h)
	440	{
	441	if (list == NULL)
	442	return;
	443
	444	bfd_vma got_offset = list->offset;
	445
	446	if (list->type == GOT_NORMAL
535b785f	447	&& !list->created_dyn_relocation)
08759e0f CM	448	{
	449	if (bfd_link_pic (info)
	450	&& h != NULL
	451	&& (info->symbolic \|\| h->dynindx == -1)
	452	&& h->def_regular)
	453	{
	454	ADD_RELA (output_bfd, got, got_offset, 0, R_ARC_RELATIVE, 0);
	455	}
	456	/* Do not fully understand the side effects of this condition.
	457	The relocation space might still being reserved. Perhaps
	458	I should clear its value. */
	459	else if (h != NULL && h->dynindx != -1)
	460	{
	461	ADD_RELA (output_bfd, got, got_offset, h->dynindx, R_ARC_GLOB_DAT, 0);
	462	}
	463	list->created_dyn_relocation = TRUE;
	464	}
	465	else if (list->existing_entries != TLS_GOT_NONE
535b785f	466	&& !list->created_dyn_relocation)
08759e0f CM	467	{
	468	/* TODO TLS: This is not called for local symbols.
	469	In order to correctly implement TLS, this should also
	470	be called for all local symbols with tls got entries.
	471	Should be moved to relocate_section in order to make it
	472	work for local symbols. */
	473	struct elf_link_hash_table *htab = elf_hash_table (info);
	474	enum tls_got_entries e = list->existing_entries;
	475
	476	BFD_ASSERT (list->type != GOT_TLS_GD
07d6d2b8	477	\|\| list->existing_entries == TLS_GOT_MOD_AND_OFF);
08759e0f CM	478
	479	bfd_vma dynindx = (h == NULL \|\| h->dynindx == -1) ? 0 : h->dynindx;
	480
	481	if (e == TLS_GOT_MOD_AND_OFF \|\| e == TLS_GOT_MOD)
	482	{
	483	ADD_RELA (output_bfd, got, got_offset, dynindx,
07d6d2b8	484	R_ARC_TLS_DTPMOD, 0);
08759e0f	485	ARC_DEBUG ("arc_info: TLS_DYNRELOC: type = %d, \
f7e8b360	486	GOT_OFFSET = %#lx, GOT_VMA = %#lx, INDEX = %ld, ADDEND = 0x0\n",
08759e0f	487	list->type,
f7e8b360 NC	488	(long) got_offset,
	489	(long) (htab->sgot->output_section->vma
	490	+ htab->sgot->output_offset + got_offset),
	491	(long) dynindx);
08759e0f	492	}
f7e8b360	493
08759e0f CM	494	if (e == TLS_GOT_MOD_AND_OFF \|\| e == TLS_GOT_OFF)
	495	{
	496	bfd_vma addend = 0;
	497	if (list->type == GOT_TLS_IE)
a0abe743	498	{
08759e0f CM	499	addend = bfd_get_32 (output_bfd,
08759e0f CM	500	htab->sgot->contents + got_offset);
a0abe743	501	}
08759e0f CM	502
	503	ADD_RELA (output_bfd, got,
	504	got_offset + (e == TLS_GOT_MOD_AND_OFF ? 4 : 0),
	505	dynindx,
	506	(list->type == GOT_TLS_IE ? R_ARC_TLS_TPOFF
	507	: R_ARC_TLS_DTPOFF),
	508	addend);
	509
	510	ARC_DEBUG ("arc_info: TLS_DYNRELOC: type = %d, \
f7e8b360	511	GOT_OFFSET = %#lx, GOT_VMA = %#lx, INDEX = %ld, ADDEND = %#lx\n",
08759e0f	512	list->type,
f7e8b360 NC	513	(long) got_offset,
	514	(long) (htab->sgot->output_section->vma
	515	+ htab->sgot->output_offset + got_offset),
	516	(long) dynindx, (long) addend);
08759e0f CM	517	}
	518	list->created_dyn_relocation = TRUE;
	519	}
	520	}
	521
	522	static void
	523	create_got_dynrelocs_for_got_info (struct got_entry **list_p,
	524	bfd *output_bfd,
	525	struct bfd_link_info * info,
07d6d2b8	526	struct elf_link_hash_entry *h)
08759e0f CM	527	{
	528	if (list_p == NULL)
	529	return;
	530
	531	struct got_entry list = list_p;
	532	/* Traverse the list of got entries for this symbol. */
	533	while (list)
	534	{
	535	create_got_dynrelocs_for_single_entry (list, output_bfd, info, h);
	536	list = list->next;
	537	}
	538	}
	539
	540	#undef ADD_SYMBOL_REF_SEC_AND_RELOC
	541
	542	#endif /* ARC_GOT_H */