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