1/* BFD back-end for TMS320C4X coff binaries.
2   Copyright (C) 1996-2017 Free Software Foundation, Inc.
3
4   Contributed by Michael Hayes (m.hayes@elec.canterbury.ac.nz)
5
6   This file is part of BFD, the Binary File Descriptor library.
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, MA
21   02110-1301, USA.  */
22
23#include "sysdep.h"
24#include "bfd.h"
25#include "libbfd.h"
26#include "bfdlink.h"
27#include "coff/tic4x.h"
28#include "coff/internal.h"
29#include "libcoff.h"
30
31#undef  F_LSYMS
32#define	F_LSYMS		F_LSYMS_TICOFF
33
34static reloc_howto_type *
35coff_tic4x_rtype_to_howto (bfd *, asection *, struct internal_reloc *,
36			   struct coff_link_hash_entry *,
37			   struct internal_syment *,  bfd_vma *);
38static void
39tic4x_reloc_processing (arelent *, struct internal_reloc *,
40			asymbol **, bfd *, asection *);
41
42/* Replace the stock _bfd_coff_is_local_label_name to recognize TI COFF local
43   labels.  */
44static bfd_boolean
45ticoff_bfd_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
46				const char *name)
47{
48  if (TICOFF_LOCAL_LABEL_P(name))
49    return TRUE;
50  return FALSE;
51}
52
53#define coff_bfd_is_local_label_name ticoff_bfd_is_local_label_name
54
55#define RELOC_PROCESSING(RELENT,RELOC,SYMS,ABFD,SECT)\
56 tic4x_reloc_processing (RELENT,RELOC,SYMS,ABFD,SECT)
57
58/* Customize coffcode.h; the default coff_ functions are set up to use
59   COFF2; coff_bad_format_hook uses BADMAG, so set that for COFF2.
60   The COFF1 and COFF0 vectors use custom _bad_format_hook procs
61   instead of setting BADMAG.  */
62#define BADMAG(x) COFF2_BADMAG(x)
63
64#undef  coff_rtype_to_howto
65#define coff_rtype_to_howto	coff_tic4x_rtype_to_howto
66
67#ifndef bfd_pe_print_pdata
68#define bfd_pe_print_pdata	NULL
69#endif
70
71#include "coffcode.h"
72
73static bfd_reloc_status_type
74tic4x_relocation (bfd *abfd ATTRIBUTE_UNUSED,
75		  arelent *reloc_entry,
76		  asymbol *symbol ATTRIBUTE_UNUSED,
77		  void * data ATTRIBUTE_UNUSED,
78		  asection *input_section,
79		  bfd *output_bfd,
80		  char **error_message ATTRIBUTE_UNUSED)
81{
82  if (output_bfd != (bfd *) NULL)
83    {
84      /* This is a partial relocation, and we want to apply the
85 	 relocation to the reloc entry rather than the raw data.
86 	 Modify the reloc inplace to reflect what we now know.  */
87      reloc_entry->address += input_section->output_offset;
88      return bfd_reloc_ok;
89    }
90  return bfd_reloc_continue;
91}
92
93reloc_howto_type tic4x_howto_table[] =
94{
95    HOWTO(R_RELWORD,	 0,  2, 16, FALSE, 0, complain_overflow_signed,   tic4x_relocation, "RELWORD",   TRUE, 0x0000ffff, 0x0000ffff, FALSE),
96    HOWTO(R_REL24,	 0,  2, 24, FALSE, 0, complain_overflow_bitfield, tic4x_relocation, "REL24",     TRUE, 0x00ffffff, 0x00ffffff, FALSE),
97    HOWTO(R_RELLONG,	 0,  2, 32, FALSE, 0, complain_overflow_dont,     tic4x_relocation, "RELLONG",   TRUE, 0xffffffff, 0xffffffff, FALSE),
98    HOWTO(R_PCRWORD,	 0,  2, 16, TRUE,  0, complain_overflow_signed,   tic4x_relocation, "PCRWORD",   TRUE, 0x0000ffff, 0x0000ffff, FALSE),
99    HOWTO(R_PCR24,	 0,  2, 24, TRUE,  0, complain_overflow_signed,   tic4x_relocation, "PCR24",     TRUE, 0x00ffffff, 0x00ffffff, FALSE),
100    HOWTO(R_PARTLS16,	 0,  2, 16, FALSE, 0, complain_overflow_dont,     tic4x_relocation, "PARTLS16",  TRUE, 0x0000ffff, 0x0000ffff, FALSE),
101    HOWTO(R_PARTMS8,	16,  2, 16, FALSE, 0, complain_overflow_dont,     tic4x_relocation, "PARTMS8",   TRUE, 0x0000ffff, 0x0000ffff, FALSE),
102    HOWTO(R_RELWORD,	 0,  2, 16, FALSE, 0, complain_overflow_signed,   tic4x_relocation, "ARELWORD",  TRUE, 0x0000ffff, 0x0000ffff, FALSE),
103    HOWTO(R_REL24,	 0,  2, 24, FALSE, 0, complain_overflow_signed,   tic4x_relocation, "AREL24",    TRUE, 0x00ffffff, 0x00ffffff, FALSE),
104    HOWTO(R_RELLONG,	 0,  2, 32, FALSE, 0, complain_overflow_signed,   tic4x_relocation, "ARELLONG",  TRUE, 0xffffffff, 0xffffffff, FALSE),
105    HOWTO(R_PCRWORD,	 0,  2, 16, TRUE,  0, complain_overflow_signed,   tic4x_relocation, "APCRWORD",  TRUE, 0x0000ffff, 0x0000ffff, FALSE),
106    HOWTO(R_PCR24,	 0,  2, 24, TRUE,  0, complain_overflow_signed,   tic4x_relocation, "APCR24",    TRUE, 0x00ffffff, 0x00ffffff, FALSE),
107    HOWTO(R_PARTLS16,	 0,  2, 16, FALSE, 0, complain_overflow_dont,     tic4x_relocation, "APARTLS16", TRUE, 0x0000ffff, 0x0000ffff, FALSE),
108    HOWTO(R_PARTMS8,	16,  2, 16, FALSE, 0, complain_overflow_dont,     tic4x_relocation, "APARTMS8",  TRUE, 0x0000ffff, 0x0000ffff, FALSE),
109};
110#define HOWTO_SIZE (sizeof(tic4x_howto_table) / sizeof(tic4x_howto_table[0]))
111
112#undef coff_bfd_reloc_type_lookup
113#define coff_bfd_reloc_type_lookup tic4x_coff_reloc_type_lookup
114#undef coff_bfd_reloc_name_lookup
115#define coff_bfd_reloc_name_lookup tic4x_coff_reloc_name_lookup
116
117/* For the case statement use the code values used tc_gen_reloc (defined in
118   bfd/reloc.c) to map to the howto table entries.  */
119
120static reloc_howto_type *
121tic4x_coff_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
122			      bfd_reloc_code_real_type code)
123{
124  unsigned int type;
125  unsigned int i;
126
127  switch (code)
128    {
129    case BFD_RELOC_32:		type = R_RELLONG; break;
130    case BFD_RELOC_24:		type = R_REL24; break;
131    case BFD_RELOC_16:		type = R_RELWORD; break;
132    case BFD_RELOC_24_PCREL:	type = R_PCR24; break;
133    case BFD_RELOC_16_PCREL:	type = R_PCRWORD; break;
134    case BFD_RELOC_HI16:	type = R_PARTMS8; break;
135    case BFD_RELOC_LO16:	type = R_PARTLS16; break;
136    default:
137      return NULL;
138    }
139
140  for (i = 0; i < HOWTO_SIZE; i++)
141    {
142      if (tic4x_howto_table[i].type == type)
143	return tic4x_howto_table + i;
144    }
145  return NULL;
146}
147
148static reloc_howto_type *
149tic4x_coff_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
150			      const char *r_name)
151{
152  unsigned int i;
153
154  for (i = 0;
155       i < sizeof (tic4x_howto_table) / sizeof (tic4x_howto_table[0]);
156       i++)
157    if (tic4x_howto_table[i].name != NULL
158	&& strcasecmp (tic4x_howto_table[i].name, r_name) == 0)
159      return &tic4x_howto_table[i];
160
161  return NULL;
162}
163
164/* Code to turn a r_type into a howto ptr, uses the above howto table.
165   Called after some initial checking by the tic4x_rtype_to_howto fn
166   below.  */
167static void
168tic4x_lookup_howto (arelent *internal,
169		    struct internal_reloc *dst)
170{
171  unsigned int i;
172  int bank = (dst->r_symndx == -1) ? HOWTO_BANK : 0;
173
174  for (i = 0; i < HOWTO_SIZE; i++)
175    {
176      if (tic4x_howto_table[i].type == dst->r_type)
177	{
178	  internal->howto = tic4x_howto_table + i + bank;
179	  return;
180	}
181    }
182
183  _bfd_error_handler (_("Unrecognized reloc type 0x%x"),
184		      (unsigned int) dst->r_type);
185  abort();
186}
187
188static reloc_howto_type *
189coff_tic4x_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
190			   asection *sec,
191			   struct internal_reloc *rel,
192			   struct coff_link_hash_entry *h ATTRIBUTE_UNUSED,
193			   struct internal_syment *sym ATTRIBUTE_UNUSED,
194			   bfd_vma *addendp)
195{
196  arelent genrel;
197
198  if (rel->r_symndx == -1 && addendp != NULL)
199    /* This is a TI "internal relocation", which means that the relocation
200       amount is the amount by which the current section is being relocated
201       in the output section.  */
202    *addendp = (sec->output_section->vma + sec->output_offset) - sec->vma;
203
204  tic4x_lookup_howto (&genrel, rel);
205
206  return genrel.howto;
207}
208
209
210static void
211tic4x_reloc_processing (arelent *relent,
212			struct internal_reloc *reloc,
213			asymbol **symbols,
214			bfd *abfd,
215			asection *section)
216{
217  asymbol *ptr;
218
219  relent->address = reloc->r_vaddr;
220
221  if (reloc->r_symndx != -1)
222    {
223      if (reloc->r_symndx < 0 || reloc->r_symndx >= obj_conv_table_size (abfd))
224        {
225	  _bfd_error_handler
226	    /* xgettext: c-format */
227            (_("%s: warning: illegal symbol index %ld in relocs"),
228             bfd_get_filename (abfd), reloc->r_symndx);
229          relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
230          ptr = NULL;
231        }
232      else
233        {
234          relent->sym_ptr_ptr = (symbols
235                                 + obj_convert (abfd)[reloc->r_symndx]);
236          ptr = *(relent->sym_ptr_ptr);
237        }
238    }
239  else
240    {
241      relent->sym_ptr_ptr = section->symbol_ptr_ptr;
242      ptr = *(relent->sym_ptr_ptr);
243    }
244
245  /* The symbols definitions that we have read in have been relocated
246     as if their sections started at 0.  But the offsets refering to
247     the symbols in the raw data have not been modified, so we have to
248     have a negative addend to compensate.
249
250     Note that symbols which used to be common must be left alone.  */
251
252  /* Calculate any reloc addend by looking at the symbol.  */
253  CALC_ADDEND (abfd, ptr, *reloc, relent);
254
255  relent->address -= section->vma;
256  /* !!     relent->section = (asection *) NULL;  */
257
258  /* Fill in the relent->howto field from reloc->r_type.  */
259  tic4x_lookup_howto (relent, reloc);
260}
261
262
263/* TI COFF v0, DOS tools (little-endian headers).  */
264CREATE_LITTLE_COFF_TARGET_VEC(tic4x_coff0_vec, "coff0-tic4x",
265			      0, SEC_CODE | SEC_READONLY, '_',
266			      NULL, &ticoff0_swap_table);
267
268/* TI COFF v0, SPARC tools (big-endian headers).  */
269CREATE_BIGHDR_COFF_TARGET_VEC(tic4x_coff0_beh_vec, "coff0-beh-tic4x",
270			      0, SEC_CODE | SEC_READONLY, '_',
271			      &tic4x_coff0_vec, &ticoff0_swap_table);
272
273/* TI COFF v1, DOS tools (little-endian headers).  */
274CREATE_LITTLE_COFF_TARGET_VEC(tic4x_coff1_vec, "coff1-tic4x",
275			      0, SEC_CODE | SEC_READONLY, '_',
276			      &tic4x_coff0_beh_vec, &ticoff1_swap_table);
277
278/* TI COFF v1, SPARC tools (big-endian headers).  */
279CREATE_BIGHDR_COFF_TARGET_VEC(tic4x_coff1_beh_vec, "coff1-beh-tic4x",
280			      0, SEC_CODE | SEC_READONLY, '_',
281			      &tic4x_coff1_vec, &ticoff1_swap_table);
282
283/* TI COFF v2, TI DOS tools output (little-endian headers).  */
284CREATE_LITTLE_COFF_TARGET_VEC(tic4x_coff2_vec, "coff2-tic4x",
285			      0, SEC_CODE | SEC_READONLY, '_',
286			      &tic4x_coff1_beh_vec, COFF_SWAP_TABLE);
287
288/* TI COFF v2, TI SPARC tools output (big-endian headers).  */
289CREATE_BIGHDR_COFF_TARGET_VEC(tic4x_coff2_beh_vec, "coff2-beh-tic4x",
290			      0, SEC_CODE | SEC_READONLY, '_',
291			      &tic4x_coff2_vec, COFF_SWAP_TABLE);
292