1 /* BFD backend for Extended Tektronix Hex Format objects.
2 Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2007 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 "sysdep.h"
69 #include "bfd.h"
70 #include "libbfd.h"
71 #include "libiberty.h"
72
73 typedef struct
74 {
75 bfd_vma low;
76 bfd_vma high;
77 } addr_range_type;
78
79 typedef struct tekhex_symbol_struct
80 {
81 asymbol symbol;
82 struct tekhex_symbol_struct *prev;
83 } tekhex_symbol_type;
84
85 static const char digs[] = "0123456789ABCDEF";
86
87 static 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
202 static void
tekhex_init(void)203 tekhex_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
237 struct 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 };
245 typedef struct tekhex_data_list_struct tekhex_data_list_type;
246
247 #define CHUNK_MASK 0x1fff
248
249 struct 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
257 typedef 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
267 static bfd_boolean
getvalue(char ** srcp,bfd_vma * valuep)268 getvalue (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
292 static bfd_boolean
getsym(char * dstp,char ** srcp,unsigned int * lenp)293 getsym (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
313 static struct data_struct *
find_chunk(bfd * abfd,bfd_vma vma)314 find_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
337 static void
insert_byte(bfd * abfd,int value,bfd_vma addr)338 insert_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
350 static bfd_boolean
first_phase(bfd * abfd,int type,char * src)351 first_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, §ion->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 break;
440 }
441 default:
442 return FALSE;
443 }
444 }
445 }
446
447 return TRUE;
448 }
449
450 /* Pass over a tekhex, calling one of the above functions on each
451 record. */
452
453 static bfd_boolean
pass_over(bfd * abfd,bfd_boolean (* func)(bfd *,int,char *))454 pass_over (bfd *abfd, bfd_boolean (*func) (bfd *, int, char *))
455 {
456 unsigned int chars_on_line;
457 bfd_boolean eof = FALSE;
458
459 /* To the front of the file. */
460 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
461 return FALSE;
462 while (! eof)
463 {
464 char src[MAXCHUNK];
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
475 /* Fetch the type and the length and the checksum. */
476 if (bfd_bread (src, (bfd_size_type) 5, abfd) != 5)
477 return FALSE;
478
479 type = src[2];
480
481 if (!ISHEX (src[0]) || !ISHEX (src[1]))
482 break;
483
484 /* Already read five chars. */
485 chars_on_line = HEX (src) - 5;
486
487 if (chars_on_line >= MAXCHUNK)
488 return FALSE;
489
490 if (bfd_bread (src, (bfd_size_type) chars_on_line, abfd) != chars_on_line)
491 return FALSE;
492
493 /* Put a null at the end. */
494 src[chars_on_line] = 0;
495
496 if (!func (abfd, type, src))
497 return FALSE;
498 }
499
500 return TRUE;
501 }
502
503 static long
tekhex_canonicalize_symtab(bfd * abfd,asymbol ** table)504 tekhex_canonicalize_symtab (bfd *abfd, asymbol **table)
505 {
506 tekhex_symbol_type *p = abfd->tdata.tekhex_data->symbols;
507 unsigned int c = bfd_get_symcount (abfd);
508
509 table[c] = 0;
510 while (p)
511 {
512 table[--c] = &(p->symbol);
513 p = p->prev;
514 }
515
516 return bfd_get_symcount (abfd);
517 }
518
519 static long
tekhex_get_symtab_upper_bound(bfd * abfd)520 tekhex_get_symtab_upper_bound (bfd *abfd)
521 {
522 return (abfd->symcount + 1) * (sizeof (struct tekhex_asymbol_struct *));
523
524 }
525
526 static bfd_boolean
tekhex_mkobject(bfd * abfd)527 tekhex_mkobject (bfd *abfd)
528 {
529 tdata_type *tdata;
530
531 tdata = bfd_alloc (abfd, (bfd_size_type) sizeof (tdata_type));
532 if (!tdata)
533 return FALSE;
534 abfd->tdata.tekhex_data = tdata;
535 tdata->type = 1;
536 tdata->head = NULL;
537 tdata->symbols = NULL;
538 tdata->data = NULL;
539 return TRUE;
540 }
541
542 /* Return TRUE if the file looks like it's in TekHex format. Just look
543 for a percent sign and some hex digits. */
544
545 static const bfd_target *
tekhex_object_p(bfd * abfd)546 tekhex_object_p (bfd *abfd)
547 {
548 char b[4];
549
550 tekhex_init ();
551
552 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
553 || bfd_bread (b, (bfd_size_type) 4, abfd) != 4)
554 return NULL;
555
556 if (b[0] != '%' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3]))
557 return NULL;
558
559 tekhex_mkobject (abfd);
560
561 if (!pass_over (abfd, first_phase))
562 return NULL;
563
564 return abfd->xvec;
565 }
566
567 static void
move_section_contents(bfd * abfd,asection * section,const void * locationp,file_ptr offset,bfd_size_type count,bfd_boolean get)568 move_section_contents (bfd *abfd,
569 asection *section,
570 const void * locationp,
571 file_ptr offset,
572 bfd_size_type count,
573 bfd_boolean get)
574 {
575 bfd_vma addr;
576 char *location = (char *) locationp;
577 bfd_vma prev_number = 1; /* Nothing can have this as a high bit. */
578 struct data_struct *d = NULL;
579
580 BFD_ASSERT (offset == 0);
581 for (addr = section->vma; count != 0; count--, addr++)
582 {
583 /* Get high bits of address. */
584 bfd_vma chunk_number = addr & ~(bfd_vma) CHUNK_MASK;
585 bfd_vma low_bits = addr & CHUNK_MASK;
586
587 if (chunk_number != prev_number)
588 /* Different chunk, so move pointer. */
589 d = find_chunk (abfd, chunk_number);
590
591 if (get)
592 {
593 if (d->chunk_init[low_bits])
594 *location = d->chunk_data[low_bits];
595 else
596 *location = 0;
597 }
598 else
599 {
600 d->chunk_data[low_bits] = *location;
601 d->chunk_init[low_bits] = (*location != 0);
602 }
603
604 location++;
605 }
606 }
607
608 static bfd_boolean
tekhex_get_section_contents(bfd * abfd,asection * section,void * locationp,file_ptr offset,bfd_size_type count)609 tekhex_get_section_contents (bfd *abfd,
610 asection *section,
611 void * locationp,
612 file_ptr offset,
613 bfd_size_type count)
614 {
615 if (section->flags & (SEC_LOAD | SEC_ALLOC))
616 {
617 move_section_contents (abfd, section, locationp, offset, count, TRUE);
618 return TRUE;
619 }
620
621 return FALSE;
622 }
623
624 static bfd_boolean
tekhex_set_arch_mach(bfd * abfd,enum bfd_architecture arch,unsigned long machine)625 tekhex_set_arch_mach (bfd *abfd,
626 enum bfd_architecture arch,
627 unsigned long machine)
628 {
629 return bfd_default_set_arch_mach (abfd, arch, machine);
630 }
631
632 /* We have to save up all the Tekhexords for a splurge before output. */
633
634 static bfd_boolean
tekhex_set_section_contents(bfd * abfd,sec_ptr section,const void * locationp,file_ptr offset,bfd_size_type bytes_to_do)635 tekhex_set_section_contents (bfd *abfd,
636 sec_ptr section,
637 const void * locationp,
638 file_ptr offset,
639 bfd_size_type bytes_to_do)
640 {
641 if (! abfd->output_has_begun)
642 {
643 /* The first time around, allocate enough sections to hold all the chunks. */
644 asection *s = abfd->sections;
645 bfd_vma vma;
646
647 for (s = abfd->sections; s; s = s->next)
648 {
649 if (s->flags & SEC_LOAD)
650 {
651 for (vma = s->vma & ~(bfd_vma) CHUNK_MASK;
652 vma < s->vma + s->size;
653 vma += CHUNK_MASK)
654 find_chunk (abfd, vma);
655 }
656 }
657 }
658
659 if (section->flags & (SEC_LOAD | SEC_ALLOC))
660 {
661 move_section_contents (abfd, section, locationp, offset, bytes_to_do,
662 FALSE);
663 return TRUE;
664 }
665
666 return FALSE;
667 }
668
669 static void
writevalue(char ** dst,bfd_vma value)670 writevalue (char **dst, bfd_vma value)
671 {
672 char *p = *dst;
673 int len;
674 int shift;
675
676 for (len = 8, shift = 28; shift; shift -= 4, len--)
677 {
678 if ((value >> shift) & 0xf)
679 {
680 *p++ = len + '0';
681 while (len)
682 {
683 *p++ = digs[(value >> shift) & 0xf];
684 shift -= 4;
685 len--;
686 }
687 *dst = p;
688 return;
689
690 }
691 }
692 *p++ = '1';
693 *p++ = '0';
694 *dst = p;
695 }
696
697 static void
writesym(char ** dst,const char * sym)698 writesym (char **dst, const char *sym)
699 {
700 char *p = *dst;
701 int len = (sym ? strlen (sym) : 0);
702
703 if (len >= 16)
704 {
705 *p++ = '0';
706 len = 16;
707 }
708 else
709 {
710 if (len == 0)
711 {
712 *p++ = '1';
713 sym = "$";
714 len = 1;
715 }
716 else
717 *p++ = digs[len];
718 }
719
720 while (len--)
721 *p++ = *sym++;
722
723 *dst = p;
724 }
725
726 static void
out(bfd * abfd,int type,char * start,char * end)727 out (bfd *abfd, int type, char *start, char *end)
728 {
729 int sum = 0;
730 char *s;
731 char front[6];
732 bfd_size_type wrlen;
733
734 front[0] = '%';
735 TOHEX (front + 1, end - start + 5);
736 front[3] = type;
737
738 for (s = start; s < end; s++)
739 sum += sum_block[(unsigned char) *s];
740
741 sum += sum_block[(unsigned char) front[1]]; /* Length. */
742 sum += sum_block[(unsigned char) front[2]];
743 sum += sum_block[(unsigned char) front[3]]; /* Type. */
744 TOHEX (front + 4, sum);
745 if (bfd_bwrite (front, (bfd_size_type) 6, abfd) != 6)
746 abort ();
747 end[0] = '\n';
748 wrlen = end - start + 1;
749 if (bfd_bwrite (start, wrlen, abfd) != wrlen)
750 abort ();
751 }
752
753 static bfd_boolean
tekhex_write_object_contents(bfd * abfd)754 tekhex_write_object_contents (bfd *abfd)
755 {
756 char buffer[100];
757 asymbol **p;
758 asection *s;
759 struct data_struct *d;
760
761 tekhex_init ();
762
763 /* And the raw data. */
764 for (d = abfd->tdata.tekhex_data->data;
765 d != NULL;
766 d = d->next)
767 {
768 int low;
769
770 const int span = 32;
771 int addr;
772
773 /* Write it in blocks of 32 bytes. */
774 for (addr = 0; addr < CHUNK_MASK + 1; addr += span)
775 {
776 int need = 0;
777
778 /* Check to see if necessary. */
779 for (low = 0; !need && low < span; low++)
780 if (d->chunk_init[addr + low])
781 need = 1;
782
783 if (need)
784 {
785 char *dst = buffer;
786
787 writevalue (&dst, addr + d->vma);
788 for (low = 0; low < span; low++)
789 {
790 TOHEX (dst, d->chunk_data[addr + low]);
791 dst += 2;
792 }
793 out (abfd, '6', buffer, dst);
794 }
795 }
796 }
797
798 /* Write all the section headers for the sections. */
799 for (s = abfd->sections; s != NULL; s = s->next)
800 {
801 char *dst = buffer;
802
803 writesym (&dst, s->name);
804 *dst++ = '1';
805 writevalue (&dst, s->vma);
806 writevalue (&dst, s->vma + s->size);
807 out (abfd, '3', buffer, dst);
808 }
809
810 /* And the symbols. */
811 if (abfd->outsymbols)
812 {
813 for (p = abfd->outsymbols; *p; p++)
814 {
815 int section_code = bfd_decode_symclass (*p);
816
817 if (section_code != '?')
818 {
819 /* Do not include debug symbols. */
820 asymbol *sym = *p;
821 char *dst = buffer;
822
823 writesym (&dst, sym->section->name);
824
825 switch (section_code)
826 {
827 case 'A':
828 *dst++ = '2';
829 break;
830 case 'a':
831 *dst++ = '6';
832 break;
833 case 'D':
834 case 'B':
835 case 'O':
836 *dst++ = '4';
837 break;
838 case 'd':
839 case 'b':
840 case 'o':
841 *dst++ = '8';
842 break;
843 case 'T':
844 *dst++ = '3';
845 break;
846 case 't':
847 *dst++ = '7';
848 break;
849 case 'C':
850 case 'U':
851 bfd_set_error (bfd_error_wrong_format);
852 return FALSE;
853 }
854
855 writesym (&dst, sym->name);
856 writevalue (&dst, sym->value + sym->section->vma);
857 out (abfd, '3', buffer, dst);
858 }
859 }
860 }
861
862 /* And the terminator. */
863 if (bfd_bwrite ("%0781010\n", (bfd_size_type) 9, abfd) != 9)
864 abort ();
865 return TRUE;
866 }
867
868 static int
tekhex_sizeof_headers(bfd * abfd ATTRIBUTE_UNUSED,struct bfd_link_info * info ATTRIBUTE_UNUSED)869 tekhex_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
870 struct bfd_link_info *info ATTRIBUTE_UNUSED)
871 {
872 return 0;
873 }
874
875 static asymbol *
tekhex_make_empty_symbol(bfd * abfd)876 tekhex_make_empty_symbol (bfd *abfd)
877 {
878 bfd_size_type amt = sizeof (struct tekhex_symbol_struct);
879 tekhex_symbol_type *new = bfd_zalloc (abfd, amt);
880
881 if (!new)
882 return NULL;
883 new->symbol.the_bfd = abfd;
884 new->prev = NULL;
885 return &(new->symbol);
886 }
887
888 static void
tekhex_get_symbol_info(bfd * abfd ATTRIBUTE_UNUSED,asymbol * symbol,symbol_info * ret)889 tekhex_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
890 asymbol *symbol,
891 symbol_info *ret)
892 {
893 bfd_symbol_info (symbol, ret);
894 }
895
896 static void
tekhex_print_symbol(bfd * abfd,void * filep,asymbol * symbol,bfd_print_symbol_type how)897 tekhex_print_symbol (bfd *abfd,
898 void * filep,
899 asymbol *symbol,
900 bfd_print_symbol_type how)
901 {
902 FILE *file = (FILE *) filep;
903
904 switch (how)
905 {
906 case bfd_print_symbol_name:
907 fprintf (file, "%s", symbol->name);
908 break;
909 case bfd_print_symbol_more:
910 break;
911
912 case bfd_print_symbol_all:
913 {
914 const char *section_name = symbol->section->name;
915
916 bfd_print_symbol_vandf (abfd, (void *) file, symbol);
917
918 fprintf (file, " %-5s %s",
919 section_name, symbol->name);
920 }
921 }
922 }
923
924 #define tekhex_close_and_cleanup _bfd_generic_close_and_cleanup
925 #define tekhex_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
926 #define tekhex_new_section_hook _bfd_generic_new_section_hook
927 #define tekhex_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
928 #define tekhex_bfd_is_local_label_name bfd_generic_is_local_label_name
929 #define tekhex_get_lineno _bfd_nosymbols_get_lineno
930 #define tekhex_find_nearest_line _bfd_nosymbols_find_nearest_line
931 #define tekhex_find_inliner_info _bfd_nosymbols_find_inliner_info
932 #define tekhex_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
933 #define tekhex_read_minisymbols _bfd_generic_read_minisymbols
934 #define tekhex_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
935 #define tekhex_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
936 #define tekhex_bfd_relax_section bfd_generic_relax_section
937 #define tekhex_bfd_gc_sections bfd_generic_gc_sections
938 #define tekhex_bfd_merge_sections bfd_generic_merge_sections
939 #define tekhex_bfd_is_group_section bfd_generic_is_group_section
940 #define tekhex_bfd_discard_group bfd_generic_discard_group
941 #define tekhex_section_already_linked _bfd_generic_section_already_linked
942 #define tekhex_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
943 #define tekhex_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
944 #define tekhex_bfd_link_add_symbols _bfd_generic_link_add_symbols
945 #define tekhex_bfd_link_just_syms _bfd_generic_link_just_syms
946 #define tekhex_bfd_final_link _bfd_generic_final_link
947 #define tekhex_bfd_link_split_section _bfd_generic_link_split_section
948 #define tekhex_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
949
950 const bfd_target tekhex_vec =
951 {
952 "tekhex", /* Name. */
953 bfd_target_tekhex_flavour,
954 BFD_ENDIAN_UNKNOWN, /* Target byte order. */
955 BFD_ENDIAN_UNKNOWN, /* Target headers byte order. */
956 (EXEC_P | /* Object flags. */
957 HAS_SYMS | HAS_LINENO | HAS_DEBUG |
958 HAS_RELOC | HAS_LOCALS | WP_TEXT | D_PAGED),
959 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
960 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags. */
961 0, /* Leading underscore. */
962 ' ', /* AR_pad_char. */
963 16, /* AR_max_namelen. */
964 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
965 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
966 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */
967 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
968 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
969 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Headers. */
970
971 {
972 _bfd_dummy_target,
973 tekhex_object_p, /* bfd_check_format. */
974 _bfd_dummy_target,
975 _bfd_dummy_target,
976 },
977 {
978 bfd_false,
979 tekhex_mkobject,
980 _bfd_generic_mkarchive,
981 bfd_false,
982 },
983 { /* bfd_write_contents. */
984 bfd_false,
985 tekhex_write_object_contents,
986 _bfd_write_archive_contents,
987 bfd_false,
988 },
989
990 BFD_JUMP_TABLE_GENERIC (tekhex),
991 BFD_JUMP_TABLE_COPY (_bfd_generic),
992 BFD_JUMP_TABLE_CORE (_bfd_nocore),
993 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
994 BFD_JUMP_TABLE_SYMBOLS (tekhex),
995 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
996 BFD_JUMP_TABLE_WRITE (tekhex),
997 BFD_JUMP_TABLE_LINK (tekhex),
998 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
999
1000 NULL,
1001
1002 NULL
1003 };
1004