1/* BFD backend for Extended Tektronix Hex Format  objects.
2   Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002,
3   2003, 2004 Free Software Foundation, Inc.
4   Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
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 2 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 02110-1301, USA.  */
21
22/* SUBSECTION
23	Tektronix Hex Format handling
24
25   DESCRIPTION
26
27	Tek Hex records can hold symbols and data, but not
28	relocations. Their main application is communication with
29	devices like PROM programmers and ICE equipment.
30
31	It seems that the sections are described as being really big,
32        the example I have says that the text section is 0..ffffffff.
33	BFD would barf with this, many apps would try to alloc 4GB to
34	read in the file.
35
36	Tex Hex may contain many sections, but the data which comes in
37	has no tag saying which section it belongs to, so we create
38	one section for each block of data, called "blknnnn" which we
39	stick all the data into.
40
41	TekHex may come out of 	order and there is no header, so an
42	initial scan is required  to discover the minimum and maximum
43	addresses used to create the vma and size of the sections we
44	create.
45	We read in the data into pages of CHUNK_MASK+1 size and read
46	them out from that whenever we need to.
47
48	Any number of sections may be created for output, we save them
49	up and output them when it's time to close the bfd.
50
51	A TekHex record looks like:
52  EXAMPLE
53	%<block length><type><checksum><stuff><cr>
54
55  DESCRIPTION
56	Where
57	o length
58	is the number of bytes in the record not including the % sign.
59	o type
60	is one of:
61	3) symbol record
62	6) data record
63	8) termination record
64
65  The data can come out of order, and may be discontigous. This is a
66  serial protocol, so big files are unlikely, so we keep a list of 8k chunks.  */
67
68#include "bfd.h"
69#include "sysdep.h"
70#include "libbfd.h"
71#include "libiberty.h"
72
73typedef struct
74{
75  bfd_vma low;
76  bfd_vma high;
77} addr_range_type;
78
79typedef struct tekhex_symbol_struct
80{
81  asymbol symbol;
82  struct tekhex_symbol_struct *prev;
83} tekhex_symbol_type;
84
85static const char digs[] = "0123456789ABCDEF";
86
87static char sum_block[256];
88
89#define NOT_HEX      20
90#define NIBBLE(x)    hex_value(x)
91#define HEX(buffer) ((NIBBLE ((buffer)[0]) << 4) + NIBBLE ((buffer)[1]))
92#define	ISHEX(x)    hex_p(x)
93#define TOHEX(d, x) \
94  (d)[1] = digs[(x) & 0xf]; \
95  (d)[0] = digs[((x)>>4)&0xf];
96
97/* Here's an example
98   %3A6C6480004E56FFFC4E717063B0AEFFFC6D0652AEFFFC60F24E5E4E75
99   %1B3709T_SEGMENT1108FFFFFFFF
100   %2B3AB9T_SEGMENT7Dgcc_compiled$1087hello$c10
101   %373829T_SEGMENT80int$t1$r1$$214741080char$t2$r2$0$12710
102   %373769T_SEGMENT80long$int$t3$r1$$1080unsigned$int$t4$10
103   %373CA9T_SEGMENT80long$unsigned$in1080short$int$t6$r1$10
104   %373049T_SEGMENT80long$long$int$t71080short$unsigned$i10
105   %373A29T_SEGMENT80long$long$unsign1080signed$char$t10$10
106   %373D69T_SEGMENT80unsigned$char$t11080float$t12$r1$4$010
107   %373D19T_SEGMENT80double$t13$r1$8$1080long$double$t14$10
108   %2734D9T_SEGMENT8Bvoid$t15$151035_main10
109   %2F3CA9T_SEGMENT81$1081$1681$1E81$21487main$F110
110   %2832F9T_SEGMENT83i$18FFFFFFFC81$1481$214
111   %07 8 10 10
112
113   explanation:
114   %3A6C6480004E56FFFC4E717063B0AEFFFC6D0652AEFFFC60F24E5E4E75
115    ^ ^^ ^     ^-data
116    | || +------ 4 char integer 0x8000
117    | |+-------- checksum
118    | +--------- type 6 (data record)
119    +----------- length 3a chars
120   <---------------------- 3a (58 chars) ------------------->
121
122   %1B3709T_SEGMENT1108FFFFFFFF
123         ^         ^^ ^- 8 character integer 0xffffffff
124         |         |+-   1 character integer 0
125         |         +--   type 1 symbol (section definition)
126         +------------   9 char symbol T_SEGMENT
127
128   %2B3AB9T_SEGMENT7Dgcc_compiled$1087hello$c10
129   %373829T_SEGMENT80int$t1$r1$$214741080char$t2$r2$0$12710
130   %373769T_SEGMENT80long$int$t3$r1$$1080unsigned$int$t4$10
131   %373CA9T_SEGMENT80long$unsigned$in1080short$int$t6$r1$10
132   %373049T_SEGMENT80long$long$int$t71080short$unsigned$i10
133   %373A29T_SEGMENT80long$long$unsign1080signed$char$t10$10
134   %373D69T_SEGMENT80unsigned$char$t11080float$t12$r1$4$010
135   %373D19T_SEGMENT80double$t13$r1$8$1080long$double$t14$10
136   %2734D9T_SEGMENT8Bvoid$t15$151035_main10
137   %2F3CA9T_SEGMENT81$1081$1681$1E81$21487main$F110
138   %2832F9T_SEGMENT83i$18FFFFFFFC81$1481$214
139   %0781010
140
141   Turns into
142   sac@thepub$ ./objdump -dx -m m68k f
143
144   f:     file format tekhex
145   -----x--- 9/55728 -134219416 Sep 29 15:13 1995 f
146   architecture: UNKNOWN!, flags 0x00000010:
147   HAS_SYMS
148   start address 0x00000000
149   SECTION 0 [D00000000]	: size 00020000 vma 00000000 align 2**0
150   ALLOC, LOAD
151   SECTION 1 [D00008000]	: size 00002001 vma 00008000 align 2**0
152
153   SECTION 2 [T_SEGMENT]	: size ffffffff vma 00000000 align 2**0
154
155   SYMBOL TABLE:
156   00000000  g       T_SEGMENT gcc_compiled$
157   00000000  g       T_SEGMENT hello$c
158   00000000  g       T_SEGMENT int$t1$r1$$21474
159   00000000  g       T_SEGMENT char$t2$r2$0$127
160   00000000  g       T_SEGMENT long$int$t3$r1$$
161   00000000  g       T_SEGMENT unsigned$int$t4$
162   00000000  g       T_SEGMENT long$unsigned$in
163   00000000  g       T_SEGMENT short$int$t6$r1$
164   00000000  g       T_SEGMENT long$long$int$t7
165   00000000  g       T_SEGMENT short$unsigned$i
166   00000000  g       T_SEGMENT long$long$unsign
167   00000000  g       T_SEGMENT signed$char$t10$
168   00000000  g       T_SEGMENT unsigned$char$t1
169   00000000  g       T_SEGMENT float$t12$r1$4$0
170   00000000  g       T_SEGMENT double$t13$r1$8$
171   00000000  g       T_SEGMENT long$double$t14$
172   00000000  g       T_SEGMENT void$t15$15
173   00000000  g       T_SEGMENT _main
174   00000000  g       T_SEGMENT $
175   00000000  g       T_SEGMENT $
176   00000000  g       T_SEGMENT $
177   00000010  g       T_SEGMENT $
178   00000000  g       T_SEGMENT main$F1
179   fcffffff  g       T_SEGMENT i$1
180   00000000  g       T_SEGMENT $
181   00000010  g       T_SEGMENT $
182
183   RELOCATION RECORDS FOR [D00000000]: (none)
184
185   RELOCATION RECORDS FOR [D00008000]: (none)
186
187   RELOCATION RECORDS FOR [T_SEGMENT]: (none)
188
189   Disassembly of section D00000000:
190   ...
191   00008000 ($+)7ff0 linkw fp,#-4
192   00008004 ($+)7ff4 nop
193   00008006 ($+)7ff6 movel #99,d0
194   00008008 ($+)7ff8 cmpl fp@(-4),d0
195   0000800c ($+)7ffc blts 00008014 ($+)8004
196   0000800e ($+)7ffe addql #1,fp@(-4)
197   00008012 ($+)8002 bras 00008006 ($+)7ff6
198   00008014 ($+)8004 unlk fp
199   00008016 ($+)8006 rts
200   ...  */
201
202static void
203tekhex_init (void)
204{
205  unsigned int i;
206  static bfd_boolean inited = FALSE;
207  int val;
208
209  if (! inited)
210    {
211      inited = TRUE;
212      hex_init ();
213      val = 0;
214      for (i = 0; i < 10; i++)
215	sum_block[i + '0'] = val++;
216
217      for (i = 'A'; i <= 'Z'; i++)
218	sum_block[i] = val++;
219
220      sum_block['$'] = val++;
221      sum_block['%'] = val++;
222      sum_block['.'] = val++;
223      sum_block['_'] = val++;
224      for (i = 'a'; i <= 'z'; i++)
225	sum_block[i] = val++;
226    }
227}
228
229/* The maximum number of bytes on a line is FF.  */
230#define MAXCHUNK 0xff
231/* The number of bytes we fit onto a line on output.  */
232#define CHUNK 21
233
234/* We cannot output our tekhexords as we see them, we have to glue them
235   together, this is done in this structure : */
236
237struct tekhex_data_list_struct
238{
239  unsigned char *data;
240  bfd_vma where;
241  bfd_size_type size;
242  struct tekhex_data_list_struct *next;
243
244};
245typedef struct tekhex_data_list_struct tekhex_data_list_type;
246
247#define CHUNK_MASK 0x1fff
248
249struct data_struct
250{
251  char chunk_data[CHUNK_MASK + 1];
252  char chunk_init[CHUNK_MASK + 1];
253  bfd_vma vma;
254  struct data_struct *next;
255};
256
257typedef struct tekhex_data_struct
258{
259  tekhex_data_list_type *head;
260  unsigned int type;
261  struct tekhex_symbol_struct *symbols;
262  struct data_struct *data;
263} tdata_type;
264
265#define enda(x) (x->vma + x->size)
266
267static bfd_boolean
268getvalue (char **srcp, bfd_vma *valuep)
269{
270  char *src = *srcp;
271  bfd_vma value = 0;
272  unsigned int len;
273
274  if (!ISHEX (*src))
275    return FALSE;
276
277  len = hex_value (*src++);
278  if (len == 0)
279    len = 16;
280  while (len--)
281    {
282      if (!ISHEX (*src))
283	return FALSE;
284      value = value << 4 | hex_value (*src++);
285    }
286
287  *srcp = src;
288  *valuep = value;
289  return TRUE;
290}
291
292static bfd_boolean
293getsym (char *dstp, char **srcp, unsigned int *lenp)
294{
295  char *src = *srcp;
296  unsigned int i;
297  unsigned int len;
298
299  if (!ISHEX (*src))
300    return FALSE;
301
302  len = hex_value (*src++);
303  if (len == 0)
304    len = 16;
305  for (i = 0; i < len; i++)
306    dstp[i] = src[i];
307  dstp[i] = 0;
308  *srcp = src + i;
309  *lenp = len;
310  return TRUE;
311}
312
313static struct data_struct *
314find_chunk (bfd *abfd, bfd_vma vma)
315{
316  struct data_struct *d = abfd->tdata.tekhex_data->data;
317
318  vma &= ~CHUNK_MASK;
319  while (d && (d->vma) != vma)
320    d = d->next;
321
322  if (!d)
323    {
324      /* No chunk for this address, so make one up.  */
325      d = bfd_zalloc (abfd, (bfd_size_type) sizeof (struct data_struct));
326
327      if (!d)
328	return NULL;
329
330      d->next = abfd->tdata.tekhex_data->data;
331      d->vma = vma;
332      abfd->tdata.tekhex_data->data = d;
333    }
334  return d;
335}
336
337static void
338insert_byte (bfd *abfd, int value, bfd_vma addr)
339{
340  /* Find the chunk that this byte needs and put it in.  */
341  struct data_struct *d = find_chunk (abfd, addr);
342
343  d->chunk_data[addr & CHUNK_MASK] = value;
344  d->chunk_init[addr & CHUNK_MASK] = 1;
345}
346
347/* The first pass is to find the names of all the sections, and see
348  how big the data is.  */
349
350static bfd_boolean
351first_phase (bfd *abfd, int type, char *src)
352{
353  asection *section = bfd_abs_section_ptr;
354  unsigned int len;
355  bfd_vma val;
356  char sym[17];			/* A symbol can only be 16chars long.  */
357
358  switch (type)
359    {
360    case '6':
361      /* Data record - read it and store it.  */
362      {
363	bfd_vma addr;
364
365	if (!getvalue (&src, &addr))
366	  return FALSE;
367
368	while (*src)
369	  {
370	    insert_byte (abfd, HEX (src), addr);
371	    src += 2;
372	    addr++;
373	  }
374      }
375
376      return TRUE;
377    case '3':
378      /* Symbol record, read the segment.  */
379      if (!getsym (sym, &src, &len))
380	return FALSE;
381      section = bfd_get_section_by_name (abfd, sym);
382      if (section == NULL)
383	{
384	  char *n = bfd_alloc (abfd, (bfd_size_type) len + 1);
385
386	  if (!n)
387	    return FALSE;
388	  memcpy (n, sym, len + 1);
389	  section = bfd_make_section (abfd, n);
390	}
391      while (*src)
392	{
393	  switch (*src)
394	    {
395	    case '1':		/* Section range.  */
396	      src++;
397	      if (!getvalue (&src, &section->vma))
398		return FALSE;
399	      if (!getvalue (&src, &val))
400		return FALSE;
401	      section->size = val - section->vma;
402	      section->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
403	      break;
404	    case '0':
405	    case '2':
406	    case '3':
407	    case '4':
408	    case '6':
409	    case '7':
410	    case '8':
411	      /* Symbols, add to section.  */
412	      {
413		bfd_size_type amt = sizeof (tekhex_symbol_type);
414		tekhex_symbol_type *new = bfd_alloc (abfd, amt);
415		char stype = (*src);
416
417		if (!new)
418		  return FALSE;
419		new->symbol.the_bfd = abfd;
420		src++;
421		abfd->symcount++;
422		abfd->flags |= HAS_SYMS;
423		new->prev = abfd->tdata.tekhex_data->symbols;
424		abfd->tdata.tekhex_data->symbols = new;
425		if (!getsym (sym, &src, &len))
426		  return FALSE;
427		new->symbol.name = bfd_alloc (abfd, (bfd_size_type) len + 1);
428		if (!new->symbol.name)
429		  return FALSE;
430		memcpy ((char *) (new->symbol.name), sym, len + 1);
431		new->symbol.section = section;
432		if (stype <= '4')
433		  new->symbol.flags = (BSF_GLOBAL | BSF_EXPORT);
434		else
435		  new->symbol.flags = BSF_LOCAL;
436		if (!getvalue (&src, &val))
437		  return FALSE;
438		new->symbol.value = val - section->vma;
439	      }
440	    default:
441	      return FALSE;
442	    }
443	}
444    }
445
446  return TRUE;
447}
448
449/* Pass over a tekhex, calling one of the above functions on each
450   record.  */
451
452static bfd_boolean
453pass_over (bfd *abfd, bfd_boolean (*func) (bfd *, int, char *))
454{
455  unsigned int chars_on_line;
456  bfd_boolean eof = FALSE;
457
458  /* To the front of the file.  */
459  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
460    abort ();
461  while (! eof)
462    {
463      char buffer[MAXCHUNK];
464      char *src = buffer;
465      char type;
466
467      /* Find first '%'.  */
468      eof = (bfd_boolean) (bfd_bread (src, (bfd_size_type) 1, abfd) != 1);
469      while (*src != '%' && !eof)
470	eof = (bfd_boolean) (bfd_bread (src, (bfd_size_type) 1, abfd) != 1);
471
472      if (eof)
473	break;
474      src++;
475
476      /* Fetch the type and the length and the checksum.  */
477      if (bfd_bread (src, (bfd_size_type) 5, abfd) != 5)
478	abort (); /* FIXME.  */
479
480      type = src[2];
481
482      if (!ISHEX (src[0]) || !ISHEX (src[1]))
483	break;
484
485      /* Already read five char.  */
486      chars_on_line = HEX (src) - 5;
487
488      if (bfd_bread (src, (bfd_size_type) chars_on_line, abfd) != chars_on_line)
489	abort (); /* FIXME.  */
490
491      /* Put a null at the end.  */
492      src[chars_on_line] = 0;
493
494      if (!func (abfd, type, src))
495	return FALSE;
496    }
497
498  return TRUE;
499}
500
501static long
502tekhex_canonicalize_symtab (bfd *abfd, asymbol **table)
503{
504  tekhex_symbol_type *p = abfd->tdata.tekhex_data->symbols;
505  unsigned int c = bfd_get_symcount (abfd);
506
507  table[c] = 0;
508  while (p)
509    {
510      table[--c] = &(p->symbol);
511      p = p->prev;
512    }
513
514  return bfd_get_symcount (abfd);
515}
516
517static long
518tekhex_get_symtab_upper_bound (bfd *abfd)
519{
520  return (abfd->symcount + 1) * (sizeof (struct tekhex_asymbol_struct *));
521
522}
523
524static bfd_boolean
525tekhex_mkobject (bfd *abfd)
526{
527  tdata_type *tdata;
528
529  tdata = bfd_alloc (abfd, (bfd_size_type) sizeof (tdata_type));
530  if (!tdata)
531    return FALSE;
532  abfd->tdata.tekhex_data = tdata;
533  tdata->type = 1;
534  tdata->head =  NULL;
535  tdata->symbols = NULL;
536  tdata->data = NULL;
537  return TRUE;
538}
539
540/* Return TRUE if the file looks like it's in TekHex format. Just look
541   for a percent sign and some hex digits.  */
542
543static const bfd_target *
544tekhex_object_p (bfd *abfd)
545{
546  char b[4];
547
548  tekhex_init ();
549
550  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
551      || bfd_bread (b, (bfd_size_type) 4, abfd) != 4)
552    return NULL;
553
554  if (b[0] != '%' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3]))
555    return NULL;
556
557  tekhex_mkobject (abfd);
558
559  if (!pass_over (abfd, first_phase))
560    return NULL;
561
562  return abfd->xvec;
563}
564
565static void
566move_section_contents (bfd *abfd,
567		       asection *section,
568		       const void * locationp,
569		       file_ptr offset,
570		       bfd_size_type count,
571		       bfd_boolean get)
572{
573  bfd_vma addr;
574  char *location = (char *) locationp;
575  bfd_vma prev_number = 1;	/* Nothing can have this as a high bit.  */
576  struct data_struct *d = NULL;
577
578  BFD_ASSERT (offset == 0);
579  for (addr = section->vma; count != 0; count--, addr++)
580    {
581      /* Get high bits of address.  */
582      bfd_vma chunk_number = addr & ~(bfd_vma) CHUNK_MASK;
583      bfd_vma low_bits = addr & CHUNK_MASK;
584
585      if (chunk_number != prev_number)
586	/* Different chunk, so move pointer. */
587	d = find_chunk (abfd, chunk_number);
588
589      if (get)
590	{
591	  if (d->chunk_init[low_bits])
592	    *location = d->chunk_data[low_bits];
593	  else
594	    *location = 0;
595	}
596      else
597	{
598	  d->chunk_data[low_bits] = *location;
599	  d->chunk_init[low_bits] = (*location != 0);
600	}
601
602      location++;
603    }
604}
605
606static bfd_boolean
607tekhex_get_section_contents (bfd *abfd,
608			     asection *section,
609			     void * locationp,
610			     file_ptr offset,
611			     bfd_size_type count)
612{
613  if (section->flags & (SEC_LOAD | SEC_ALLOC))
614    {
615      move_section_contents (abfd, section, locationp, offset, count, TRUE);
616      return TRUE;
617    }
618
619  return FALSE;
620}
621
622static bfd_boolean
623tekhex_set_arch_mach (bfd *abfd,
624		      enum bfd_architecture arch,
625		      unsigned long machine)
626{
627  return bfd_default_set_arch_mach (abfd, arch, machine);
628}
629
630/* We have to save up all the Tekhexords for a splurge before output.  */
631
632static bfd_boolean
633tekhex_set_section_contents (bfd *abfd,
634			     sec_ptr section,
635			     const void * locationp,
636			     file_ptr offset,
637			     bfd_size_type bytes_to_do)
638{
639  if (! abfd->output_has_begun)
640    {
641      /* The first time around, allocate enough sections to hold all the chunks.  */
642      asection *s = abfd->sections;
643      bfd_vma vma;
644
645      for (s = abfd->sections; s; s = s->next)
646	{
647	  if (s->flags & SEC_LOAD)
648	    {
649	      for (vma = s->vma & ~(bfd_vma) CHUNK_MASK;
650		   vma < s->vma + s->size;
651		   vma += CHUNK_MASK)
652		find_chunk (abfd, vma);
653	    }
654	}
655    }
656
657  if (section->flags & (SEC_LOAD | SEC_ALLOC))
658    {
659      move_section_contents (abfd, section, locationp, offset, bytes_to_do,
660			     FALSE);
661      return TRUE;
662    }
663
664  return FALSE;
665}
666
667static void
668writevalue (char **dst, bfd_vma value)
669{
670  char *p = *dst;
671  int len;
672  int shift;
673
674  for (len = 8, shift = 28; shift; shift -= 4, len--)
675    {
676      if ((value >> shift) & 0xf)
677	{
678	  *p++ = len + '0';
679	  while (len)
680	    {
681	      *p++ = digs[(value >> shift) & 0xf];
682	      shift -= 4;
683	      len--;
684	    }
685	  *dst = p;
686	  return;
687
688	}
689    }
690  *p++ = '1';
691  *p++ = '0';
692  *dst = p;
693}
694
695static void
696writesym (char **dst, const char *sym)
697{
698  char *p = *dst;
699  int len = (sym ? strlen (sym) : 0);
700
701  if (len >= 16)
702    {
703      *p++ = '0';
704      len = 16;
705    }
706  else
707    {
708      if (len == 0)
709	{
710	  *p++ = '1';
711	  sym = "$";
712	  len = 1;
713	}
714      else
715	*p++ = digs[len];
716    }
717
718  while (len--)
719    *p++ = *sym++;
720
721  *dst = p;
722}
723
724static void
725out (bfd *abfd, int type, char *start, char *end)
726{
727  int sum = 0;
728  char *s;
729  char front[6];
730  bfd_size_type wrlen;
731
732  front[0] = '%';
733  TOHEX (front + 1, end - start + 5);
734  front[3] = type;
735
736  for (s = start; s < end; s++)
737    sum += sum_block[(unsigned char) *s];
738
739  sum += sum_block[(unsigned char) front[1]];	/* Length.  */
740  sum += sum_block[(unsigned char) front[2]];
741  sum += sum_block[(unsigned char) front[3]];	/* Type.  */
742  TOHEX (front + 4, sum);
743  if (bfd_bwrite (front, (bfd_size_type) 6, abfd) != 6)
744    abort ();
745  end[0] = '\n';
746  wrlen = end - start + 1;
747  if (bfd_bwrite (start, wrlen, abfd) != wrlen)
748    abort ();
749}
750
751static bfd_boolean
752tekhex_write_object_contents (bfd *abfd)
753{
754  int bytes_written;
755  char buffer[100];
756  asymbol **p;
757  asection *s;
758  struct data_struct *d;
759
760  tekhex_init ();
761
762  bytes_written = 0;
763
764  /* And the raw data.  */
765  for (d = abfd->tdata.tekhex_data->data;
766       d != NULL;
767       d = d->next)
768    {
769      int low;
770
771      const int span = 32;
772      int addr;
773
774      /* Write it in blocks of 32 bytes.  */
775      for (addr = 0; addr < CHUNK_MASK + 1; addr += span)
776	{
777	  int need = 0;
778
779	  /* Check to see if necessary.  */
780	  for (low = 0; !need && low < span; low++)
781	    if (d->chunk_init[addr + low])
782	      need = 1;
783
784	  if (need)
785	    {
786	      char *dst = buffer;
787
788	      writevalue (&dst, addr + d->vma);
789	      for (low = 0; low < span; low++)
790		{
791		  TOHEX (dst, d->chunk_data[addr + low]);
792		  dst += 2;
793		}
794	      out (abfd, '6', buffer, dst);
795	    }
796	}
797    }
798
799  /* Write all the section headers for the sections.  */
800  for (s = abfd->sections; s != NULL; s = s->next)
801    {
802      char *dst = buffer;
803
804      writesym (&dst, s->name);
805      *dst++ = '1';
806      writevalue (&dst, s->vma);
807      writevalue (&dst, s->vma + s->size);
808      out (abfd, '3', buffer, dst);
809    }
810
811  /* And the symbols.  */
812  if (abfd->outsymbols)
813    {
814      for (p = abfd->outsymbols; *p; p++)
815	{
816	  int section_code = bfd_decode_symclass (*p);
817
818	  if (section_code != '?')
819	    {
820	      /* Do not include debug symbols.  */
821	      asymbol *sym = *p;
822	      char *dst = buffer;
823
824	      writesym (&dst, sym->section->name);
825
826	      switch (section_code)
827		{
828		case 'A':
829		  *dst++ = '2';
830		  break;
831		case 'a':
832		  *dst++ = '6';
833		  break;
834		case 'D':
835		case 'B':
836		case 'O':
837		  *dst++ = '4';
838		  break;
839		case 'd':
840		case 'b':
841		case 'o':
842		  *dst++ = '8';
843		  break;
844		case 'T':
845		  *dst++ = '3';
846		  break;
847		case 't':
848		  *dst++ = '7';
849		  break;
850		case 'C':
851		case 'U':
852		  bfd_set_error (bfd_error_wrong_format);
853		  return FALSE;
854		}
855
856	      writesym (&dst, sym->name);
857	      writevalue (&dst, sym->value + sym->section->vma);
858	      out (abfd, '3', buffer, dst);
859	    }
860	}
861    }
862
863  /* And the terminator.  */
864  if (bfd_bwrite ("%0781010\n", (bfd_size_type) 9, abfd) != 9)
865    abort ();
866  return TRUE;
867}
868
869static int
870tekhex_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
871		       bfd_boolean exec ATTRIBUTE_UNUSED)
872{
873  return 0;
874}
875
876static asymbol *
877tekhex_make_empty_symbol (bfd *abfd)
878{
879  bfd_size_type amt = sizeof (struct tekhex_symbol_struct);
880  tekhex_symbol_type *new = bfd_zalloc (abfd, amt);
881
882  if (!new)
883    return NULL;
884  new->symbol.the_bfd = abfd;
885  new->prev =  NULL;
886  return &(new->symbol);
887}
888
889static void
890tekhex_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
891			asymbol *symbol,
892			symbol_info *ret)
893{
894  bfd_symbol_info (symbol, ret);
895}
896
897static void
898tekhex_print_symbol (bfd *abfd,
899		     void * filep,
900		     asymbol *symbol,
901		     bfd_print_symbol_type how)
902{
903  FILE *file = (FILE *) filep;
904
905  switch (how)
906    {
907    case bfd_print_symbol_name:
908      fprintf (file, "%s", symbol->name);
909      break;
910    case bfd_print_symbol_more:
911      break;
912
913    case bfd_print_symbol_all:
914      {
915	const char *section_name = symbol->section->name;
916
917	bfd_print_symbol_vandf (abfd, (void *) file, symbol);
918
919	fprintf (file, " %-5s %s",
920		 section_name, symbol->name);
921      }
922    }
923}
924
925#define	tekhex_close_and_cleanup                    _bfd_generic_close_and_cleanup
926#define tekhex_bfd_free_cached_info                 _bfd_generic_bfd_free_cached_info
927#define tekhex_new_section_hook                     _bfd_generic_new_section_hook
928#define tekhex_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
929#define tekhex_bfd_is_local_label_name               bfd_generic_is_local_label_name
930#define tekhex_get_lineno                           _bfd_nosymbols_get_lineno
931#define tekhex_find_nearest_line                    _bfd_nosymbols_find_nearest_line
932#define tekhex_find_inliner_info                    _bfd_nosymbols_find_inliner_info
933#define tekhex_bfd_make_debug_symbol                _bfd_nosymbols_bfd_make_debug_symbol
934#define tekhex_read_minisymbols                     _bfd_generic_read_minisymbols
935#define tekhex_minisymbol_to_symbol                 _bfd_generic_minisymbol_to_symbol
936#define tekhex_bfd_get_relocated_section_contents   bfd_generic_get_relocated_section_contents
937#define tekhex_bfd_relax_section                    bfd_generic_relax_section
938#define tekhex_bfd_gc_sections                      bfd_generic_gc_sections
939#define tekhex_bfd_merge_sections                   bfd_generic_merge_sections
940#define tekhex_bfd_is_group_section                 bfd_generic_is_group_section
941#define tekhex_bfd_discard_group                    bfd_generic_discard_group
942#define tekhex_section_already_linked               _bfd_generic_section_already_linked
943#define tekhex_bfd_link_hash_table_create           _bfd_generic_link_hash_table_create
944#define tekhex_bfd_link_hash_table_free             _bfd_generic_link_hash_table_free
945#define tekhex_bfd_link_add_symbols                 _bfd_generic_link_add_symbols
946#define tekhex_bfd_link_just_syms                   _bfd_generic_link_just_syms
947#define tekhex_bfd_final_link                       _bfd_generic_final_link
948#define tekhex_bfd_link_split_section               _bfd_generic_link_split_section
949#define tekhex_get_section_contents_in_window       _bfd_generic_get_section_contents_in_window
950
951const bfd_target tekhex_vec =
952{
953  "tekhex",			/* Name.  */
954  bfd_target_tekhex_flavour,
955  BFD_ENDIAN_UNKNOWN,		/* Target byte order.  */
956  BFD_ENDIAN_UNKNOWN,		/* Target headers byte order.  */
957  (EXEC_P |			/* Object flags.  */
958   HAS_SYMS | HAS_LINENO | HAS_DEBUG |
959   HAS_RELOC | HAS_LOCALS | WP_TEXT | D_PAGED),
960  (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
961   | SEC_ALLOC | SEC_LOAD | SEC_RELOC),	/* Section flags.  */
962  0,				/* Leading underscore.  */
963  ' ',				/* AR_pad_char.  */
964  16,				/* AR_max_namelen.  */
965  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
966  bfd_getb32, bfd_getb_signed_32, bfd_putb32,
967  bfd_getb16, bfd_getb_signed_16, bfd_putb16,	/* Data.  */
968  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
969  bfd_getb32, bfd_getb_signed_32, bfd_putb32,
970  bfd_getb16, bfd_getb_signed_16, bfd_putb16,	/* Headers.  */
971
972  {
973    _bfd_dummy_target,
974    tekhex_object_p,		/* bfd_check_format.  */
975    _bfd_dummy_target,
976    _bfd_dummy_target,
977  },
978  {
979    bfd_false,
980    tekhex_mkobject,
981    _bfd_generic_mkarchive,
982    bfd_false,
983  },
984  {				/* bfd_write_contents.  */
985    bfd_false,
986    tekhex_write_object_contents,
987    _bfd_write_archive_contents,
988    bfd_false,
989  },
990
991  BFD_JUMP_TABLE_GENERIC (tekhex),
992  BFD_JUMP_TABLE_COPY (_bfd_generic),
993  BFD_JUMP_TABLE_CORE (_bfd_nocore),
994  BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
995  BFD_JUMP_TABLE_SYMBOLS (tekhex),
996  BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
997  BFD_JUMP_TABLE_WRITE (tekhex),
998  BFD_JUMP_TABLE_LINK (tekhex),
999  BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1000
1001  NULL,
1002
1003  NULL
1004};
1005