1/* BFD back-end for Zilog Z800n COFF binaries.
2   Copyright 1992, 1993, 1994, 1995, 1997, 1999, 2000, 2001, 2002, 2003
3   Free Software Foundation, Inc.
4   Contributed by Cygnus Support.
5   Written by Steve Chamberlain, <sac@cygnus.com>.
6
7This file is part of BFD, the Binary File Descriptor library.
8
9This program is free software; you can redistribute it and/or modify
10it under the terms of the GNU General Public License as published by
11the Free Software Foundation; either version 2 of the License, or
12(at your option) any later version.
13
14This program is distributed in the hope that it will be useful,
15but WITHOUT ANY WARRANTY; without even the implied warranty of
16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17GNU General Public License for more details.
18
19You should have received a copy of the GNU General Public License
20along with this program; if not, write to the Free Software
21Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
22
23#include "bfd.h"
24#include "sysdep.h"
25#include "libbfd.h"
26#include "bfdlink.h"
27#include "coff/z8k.h"
28#include "coff/internal.h"
29#include "libcoff.h"
30
31#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (1)
32
33static reloc_howto_type r_imm32 =
34HOWTO (R_IMM32, 0, 2, 32, FALSE, 0,
35       complain_overflow_bitfield, 0, "r_imm32", TRUE, 0xffffffff,
36       0xffffffff, FALSE);
37
38static reloc_howto_type r_imm4l =
39HOWTO (R_IMM4L, 0, 0, 4, FALSE, 0,
40       complain_overflow_bitfield, 0, "r_imm4l", TRUE, 0xf, 0xf, FALSE);
41
42static reloc_howto_type r_da =
43HOWTO (R_IMM16, 0, 1, 16, FALSE, 0,
44       complain_overflow_bitfield, 0, "r_da", TRUE, 0x0000ffff, 0x0000ffff,
45       FALSE);
46
47static reloc_howto_type r_imm8 =
48HOWTO (R_IMM8, 0, 0, 8, FALSE, 0,
49       complain_overflow_bitfield, 0, "r_imm8", TRUE, 0x000000ff, 0x000000ff,
50       FALSE);
51
52static reloc_howto_type r_rel16 =
53HOWTO (R_REL16, 0, 1, 16, FALSE, 0,
54       complain_overflow_bitfield, 0, "r_rel16", TRUE, 0x0000ffff, 0x0000ffff,
55       TRUE);
56
57static reloc_howto_type r_jr =
58HOWTO (R_JR, 0, 0, 8, TRUE, 0, complain_overflow_signed, 0,
59       "r_jr", TRUE, 0, 0, TRUE);
60
61static reloc_howto_type r_disp7 =
62HOWTO (R_DISP7, 0, 0, 7, TRUE, 0, complain_overflow_bitfield, 0,
63       "r_disp7", TRUE, 0, 0, TRUE);
64
65static reloc_howto_type r_callr =
66HOWTO (R_CALLR, 0, 1, 12, TRUE, 0, complain_overflow_signed, 0,
67       "r_callr", TRUE, 0xfff, 0xfff, TRUE);
68
69/* Turn a howto into a reloc number */
70
71static int
72coff_z8k_select_reloc (reloc_howto_type *howto)
73{
74  return howto->type;
75}
76
77#define SELECT_RELOC(x,howto) x.r_type = coff_z8k_select_reloc(howto)
78
79#define BADMAG(x) Z8KBADMAG(x)
80#define Z8K 1			/* Customize coffcode.h */
81#define __A_MAGIC_SET__
82
83/* Code to swap in the reloc.  */
84#define SWAP_IN_RELOC_OFFSET	H_GET_32
85#define SWAP_OUT_RELOC_OFFSET	H_PUT_32
86#define SWAP_OUT_RELOC_EXTRA(abfd, src, dst) \
87  dst->r_stuff[0] = 'S'; \
88  dst->r_stuff[1] = 'C';
89
90/* Code to turn a r_type into a howto ptr, uses the above howto table.  */
91
92static void
93rtype2howto (arelent *internal, struct internal_reloc *dst)
94{
95  switch (dst->r_type)
96    {
97    default:
98      abort ();
99      break;
100    case R_IMM8:
101      internal->howto = &r_imm8;
102      break;
103     case R_IMM16:
104      internal->howto = &r_da;
105      break;
106    case R_JR:
107      internal->howto = &r_jr;
108      break;
109    case R_DISP7:
110      internal->howto = &r_disp7;
111      break;
112    case R_CALLR:
113      internal->howto = &r_callr;
114      break;
115    case R_REL16:
116      internal->howto = &r_rel16;
117      break;
118    case R_IMM32:
119      internal->howto = &r_imm32;
120      break;
121    case R_IMM4L:
122      internal->howto = &r_imm4l;
123      break;
124    }
125}
126
127#define RTYPE2HOWTO(internal, relocentry) rtype2howto (internal, relocentry)
128
129/* Perform any necessary magic to the addend in a reloc entry.  */
130
131#define CALC_ADDEND(abfd, symbol, ext_reloc, cache_ptr) \
132 cache_ptr->addend =  ext_reloc.r_offset;
133
134#define RELOC_PROCESSING(relent,reloc,symbols,abfd,section) \
135 reloc_processing(relent, reloc, symbols, abfd, section)
136
137static void
138reloc_processing (arelent *relent,
139                  struct internal_reloc *reloc,
140                  asymbol **symbols,
141                  bfd *abfd,
142                  asection *section)
143{
144  relent->address = reloc->r_vaddr;
145  rtype2howto (relent, reloc);
146
147  if (reloc->r_symndx > 0)
148    relent->sym_ptr_ptr = symbols + obj_convert (abfd)[reloc->r_symndx];
149  else
150    relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
151
152  relent->addend = reloc->r_offset;
153  relent->address -= section->vma;
154}
155
156static void
157extra_case (bfd *in_abfd,
158            struct bfd_link_info *link_info,
159            struct bfd_link_order *link_order,
160            arelent *reloc,
161            bfd_byte *data,
162            unsigned int *src_ptr,
163            unsigned int *dst_ptr)
164{
165  asection * input_section = link_order->u.indirect.section;
166
167  switch (reloc->howto->type)
168    {
169    case R_IMM8:
170      bfd_put_8 (in_abfd,
171		 bfd_coff_reloc16_get_value (reloc, link_info, input_section),
172		 data + *dst_ptr);
173      (*dst_ptr) += 1;
174      (*src_ptr) += 1;
175      break;
176
177    case R_IMM32:
178      /* If no flags are set, assume immediate value.  */
179      if (! (*reloc->sym_ptr_ptr)->section->flags)
180	{
181	  bfd_put_32 (in_abfd,
182		      bfd_coff_reloc16_get_value (reloc, link_info,
183						  input_section),
184		      data + *dst_ptr);
185	}
186      else
187	{
188	  bfd_vma dst = bfd_coff_reloc16_get_value (reloc, link_info,
189						    input_section);
190	  /* Addresses are 23 bit, and the layout of those in a 32-bit
191	     value is as follows:
192	       1AAAAAAA xxxxxxxx AAAAAAAA AAAAAAAA
193	     (A - address bits,  x - ignore).  */
194	  dst = (dst & 0xffff) | ((dst & 0xff0000) << 8) | 0x80000000;
195	  bfd_put_32 (in_abfd, dst, data + *dst_ptr);
196	}
197      (*dst_ptr) += 4;
198      (*src_ptr) += 4;
199      break;
200
201    case R_IMM4L:
202      bfd_put_8 (in_abfd,
203		 ((bfd_get_8 (in_abfd, data + *dst_ptr) & 0xf0)
204		  | (0x0f
205		     & bfd_coff_reloc16_get_value (reloc, link_info,
206						   input_section))),
207		 data + *dst_ptr);
208      (*dst_ptr) += 1;
209      (*src_ptr) += 1;
210      break;
211
212    case R_IMM16:
213      bfd_put_16 (in_abfd,
214		  bfd_coff_reloc16_get_value (reloc, link_info, input_section),
215		  data + *dst_ptr);
216      (*dst_ptr) += 2;
217      (*src_ptr) += 2;
218      break;
219
220    case R_JR:
221      {
222	bfd_vma dst = bfd_coff_reloc16_get_value (reloc, link_info,
223						  input_section);
224	bfd_vma dot = (link_order->offset
225		       + *dst_ptr
226		       + input_section->output_section->vma);
227	int gap = dst - dot - 1;  /* -1, since we're in the odd byte of the
228                                     word and the pc's been incremented.  */
229
230	if (gap & 1)
231	  abort ();
232	gap /= 2;
233	if (gap > 128 || gap < -128)
234	  {
235	    if (! ((*link_info->callbacks->reloc_overflow)
236		   (link_info, bfd_asymbol_name (*reloc->sym_ptr_ptr),
237		    reloc->howto->name, reloc->addend, input_section->owner,
238		    input_section, reloc->address)))
239	      abort ();
240	  }
241	bfd_put_8 (in_abfd, gap, data + *dst_ptr);
242	(*dst_ptr)++;
243	(*src_ptr)++;
244	break;
245      }
246
247    case R_DISP7:
248      {
249	bfd_vma dst = bfd_coff_reloc16_get_value (reloc, link_info,
250						  input_section);
251	bfd_vma dot = (link_order->offset
252		       + *dst_ptr
253		       + input_section->output_section->vma);
254	int gap = dst - dot - 1;  /* -1, since we're in the odd byte of the
255                                     word and the pc's been incremented.  */
256
257	if (gap & 1)
258	  abort ();
259	gap /= 2;
260
261	if (gap > 0 || gap < -127)
262	  {
263	    if (! ((*link_info->callbacks->reloc_overflow)
264		   (link_info, bfd_asymbol_name (*reloc->sym_ptr_ptr),
265		    reloc->howto->name, reloc->addend, input_section->owner,
266		    input_section, reloc->address)))
267	      abort ();
268	  }
269	bfd_put_8 (in_abfd,
270                   (bfd_get_8 ( in_abfd, data + *dst_ptr) & 0x80) + (-gap & 0x7f),
271                   data + *dst_ptr);
272	(*dst_ptr)++;
273	(*src_ptr)++;
274	break;
275      }
276
277    case R_CALLR:
278      {
279	bfd_vma dst = bfd_coff_reloc16_get_value (reloc, link_info,
280						  input_section);
281	bfd_vma dot = (link_order->offset
282		       + *dst_ptr
283		       + input_section->output_section->vma);
284	int gap = dst - dot - 2;
285
286	if (gap & 1)
287	  abort ();
288	if (gap > 4096 || gap < -4095)
289	  {
290	    if (! ((*link_info->callbacks->reloc_overflow)
291		   (link_info, bfd_asymbol_name (*reloc->sym_ptr_ptr),
292		    reloc->howto->name, reloc->addend, input_section->owner,
293		    input_section, reloc->address)))
294	      abort ();
295	  }
296	gap /= 2;
297	bfd_put_16 (in_abfd,
298                    (bfd_get_16 ( in_abfd, data + *dst_ptr) & 0xf000) | (-gap & 0x0fff),
299                    data + *dst_ptr);
300	(*dst_ptr) += 2;
301	(*src_ptr) += 2;
302	break;
303      }
304
305    case R_REL16:
306      {
307	bfd_vma dst = bfd_coff_reloc16_get_value (reloc, link_info,
308						  input_section);
309	bfd_vma dot = (link_order->offset
310		       + *dst_ptr
311		       + input_section->output_section->vma);
312	int gap = dst - dot - 2;
313
314	if (gap > 32767 || gap < -32768)
315	  {
316	    if (! ((*link_info->callbacks->reloc_overflow)
317		   (link_info, bfd_asymbol_name (*reloc->sym_ptr_ptr),
318		    reloc->howto->name, reloc->addend, input_section->owner,
319		    input_section, reloc->address)))
320	      abort ();
321	  }
322	bfd_put_16 (in_abfd, (bfd_vma) gap, data + *dst_ptr);
323	(*dst_ptr) += 2;
324	(*src_ptr) += 2;
325	break;
326      }
327
328    default:
329      abort ();
330    }
331}
332
333#define coff_reloc16_extra_cases extra_case
334
335#include "coffcode.h"
336
337#undef  coff_bfd_get_relocated_section_contents
338#undef coff_bfd_relax_section
339#define coff_bfd_get_relocated_section_contents \
340  bfd_coff_reloc16_get_relocated_section_contents
341#define coff_bfd_relax_section bfd_coff_reloc16_relax_section
342
343CREATE_BIG_COFF_TARGET_VEC (z8kcoff_vec, "coff-z8k", 0, 0, '_', NULL, COFF_SWAP_TABLE)
344