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

/* ARC-specific support for 32-bit ELF
   Copyright (C) 1994-2016 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

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;
};

static struct got_entry **
arc_get_local_got_ents (bfd * abfd)
{
  static struct got_entry **local_got_ents = NULL;

  if (local_got_ents == NULL)
    {
      size_t	   size;
      Elf_Internal_Shdr *symtab_hdr = &((elf_tdata (abfd))->symtab_hdr);

      size = symtab_hdr->sh_info * sizeof (bfd_vma);
      local_got_ents = (struct got_entry **)
	bfd_alloc (abfd, sizeof (struct got_entry *) * size);
      if (local_got_ents == NULL)
	return FALSE;

      memset (local_got_ents, 0, sizeof (struct got_entry *) * size);
      elf_local_got_ents (abfd) = local_got_ents;
    }

  return local_got_ents;
}

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)
{
  if (h != NULL)
    {
      return &h->got.glist;
    }
  else
    {
      struct got_entry **local_got_ents
	= arc_get_local_got_ents (abfd);
      return &local_got_ents[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
      || (! 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 == FALSE)
	{
	  switch (entry->type)
	    {
	    case GOT_TLS_GD:
	      {
		BFD_ASSERT (tls_sec && tls_sec->output_section);
		bfd_vma sec_vma = tls_sec->output_section->vma;

		bfd_put_32 (output_bfd,
			    sym_value - sec_vma,
			    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),
			   htab->sgot->contents + 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;

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