arc-got.h revision 1.1.1.1 
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
25enum 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
34enum 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
42struct 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
52static struct got_entry **
53arc_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
75static struct got_entry *
76got_entry_for_type (struct got_entry **list,
77		    enum tls_type_e type)
78{
79  struct got_entry **p = list;
80
81  while (*p != NULL)
82    {
83      if ((*p)->type == type)
84	return *p;
85      p = &((*p)->next);
86    }
87  return NULL;
88}
89
90static void
91new_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;
99  struct got_entry *entry;
100
101  while (*p != NULL)
102    {
103      if ((*p)->type == type)
104	return;
105      p = &((*p)->next);
106    }
107
108  entry = (struct got_entry *) xmalloc (sizeof (struct got_entry));
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: "
118	     "type: %d, offset: %ld, existing_entries: %d\n",
119	     type, (long) offset, existing_entries);
120
121  /* Add the entry to the end of the list.  */
122  *p = entry;
123}
124
125static enum tls_type_e
126tls_type_for_reloc (reloc_howto_type *howto)
127{
128  enum tls_type_e ret = GOT_UNKNOWN;
129
130  if (is_reloc_for_GOT (howto))
131    return GOT_NORMAL;
132
133  switch (howto->type)
134    {
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;
147    }
148
149  return ret;
150};
151
152static struct got_entry **
153get_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
170static enum tls_type_e
171arc_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))
176    return  GOT_NORMAL;
177
178  if (is_reloc_for_TLS (howto))
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
213static bfd_boolean
214arc_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
262static bfd_vma
263relocate_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)
272{
273  struct elf_link_hash_table *htab = elf_hash_table (info);
274  struct got_entry *entry = NULL;
275
276  if (list_p == NULL || type == GOT_UNKNOWN || type == GOT_TLS_LE)
277    return 0;
278
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)
285	      && SYMBOL_REFERENCES_LOCAL (info, h))))
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
299	    + h->root.u.def.section->output_section->vma
300	    + h->root.u.def.section->output_offset;
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
312	    + sec->output_section->vma
313	    + sec->output_offset;
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	    {
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
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
383		  {
384		    bfd_put_32 (output_bfd,
385				reloc_data->sym_value + sec_vma,
386				htab->sgot->contents + entry->offset);
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		  }
395	      }
396	      break;
397	    default:
398	      BFD_ASSERT (0);
399	      break;
400	    }
401	  entry->processed = TRUE;
402	}
403    }
404
405  return entry->offset;
406}
407
408static void
409create_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, \
459GOT_OFFSET = %#lx, GOT_VMA = %#lx, INDEX = %ld, ADDEND = 0x0\n",
460			 list->type,
461			 (long) got_offset,
462			 (long) (htab->sgot->output_section->vma
463				 + htab->sgot->output_offset + got_offset),
464			 (long) dynindx);
465	}
466
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, \
482GOT_OFFSET = %#lx, GOT_VMA = %#lx, INDEX = %ld, ADDEND = %#lx\n",
483		     list->type,
484		     (long) got_offset,
485		     (long) (htab->sgot->output_section->vma
486			     + htab->sgot->output_offset + got_offset),
487		     (long) dynindx, (long) addend);
488	}
489      list->created_dyn_relocation = TRUE;
490    }
491}
492
493static void
494create_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 */
514