projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* bfd.c: Use right name for tekhex tdata struct.
[deliverable/binutils-gdb.git] / bfd / tekhex.c
CommitLineData
d3e667e8
JG		 1/* BFD backend for Extended Tektronix Hex Format objects.
2 Copyright (C) 1992 Free Software Foundation, Inc.
3
4 Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
5
6This file is part of BFD, the Binary File Descriptor library.
7
8This program is free software; you can redistribute it and/or modify
9it under the terms of the GNU General Public License as published by
10the Free Software Foundation; either version 2 of the License, or
11(at your option) any later version.
12
13This program is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16GNU General Public License for more details.
17
18You should have received a copy of the GNU General Public License
19along with this program; if not, write to the Free Software
20Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
21
22/*
23SUBSECTION
24 Tektronix Hex Format handling
25
26DESCRIPTION
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 descibed 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
53 A TekHex record looks like:
54EXAMPLE
55 %<block length><type><checksum><stuff><cr>
56
57DESCRIPTION
58 Where
59 o length
60 is the number of bytes in the record not including the % sign.
61 o type
62 is one of:
63 3) symbol record
64 6) data record
65 8) termination record
66
67
68The data can come out of order, and may be discontigous. This is a
69serial protocol, so big files are unlikely, so we keep a list of 8k chunks
70*/
71
72#include "bfd.h"
73#include "sysdep.h"
74#include "libbfd.h"
75
76typedef struct {
77bfd_vma low;
78bfd_vma high;
79} addr_range_type;
80
81typedef struct tekhex_symbol_struct {
82
83 asymbol symbol;
84struct tekhex_symbol_struct *prev;
85
86} tekhex_symbol_type;
87
88static char digs[] = "0123456789ABCDEF";
89
90static char sum_block[256];
91/* Horrible ascii dependent macros for converting between hex and
92 binary */
93
94#define CHARS_IN_SET 256
95static char hex_value[CHARS_IN_SET];
96#define NOT_HEX 20
97#define NIBBLE(x) hex_value[x]
98#define HEX(buffer) ((NIBBLE((buffer)[0])<<4) + NIBBLE((buffer)[1]))
99#define TOHEX(d,x) \
100(d)[1] = digs[(x) & 0xf]; \
101(d)[0] = digs[((x)>>4)&0xf];
102#define ISHEX(x) (hex_value[x] != NOT_HEX)
103
104/*
105Here's an example
106%3A6C6480004E56FFFC4E717063B0AEFFFC6D0652AEFFFC60F24E5E4E75
107%1B3709T_SEGMENT1108FFFFFFFF
108%2B3AB9T_SEGMENT7Dgcc_compiled$1087hello$c10
109%373829T_SEGMENT80int$t1$r1$$214741080char$t2$r2$0$12710
110%373769T_SEGMENT80long$int$t3$r1$$1080unsigned$int$t4$10
111%373CA9T_SEGMENT80long$unsigned$in1080short$int$t6$r1$10
112%373049T_SEGMENT80long$long$int$t71080short$unsigned$i10
113%373A29T_SEGMENT80long$long$unsign1080signed$char$t10$10
114%373D69T_SEGMENT80unsigned$char$t11080float$t12$r1$4$010
115%373D19T_SEGMENT80double$t13$r1$8$1080long$double$t14$10
116%2734D9T_SEGMENT8Bvoid$t15$151035_main10
117%2F3CA9T_SEGMENT81$1081$1681$1E81$21487main$F110
118%2832F9T_SEGMENT83i$18FFFFFFFC81$1481$214
119%07 8 10 10
120
121explanation:
122%3A6C6480004E56FFFC4E717063B0AEFFFC6D0652AEFFFC60F24E5E4E75
123 ^ ^^ ^ ^-data
124 | || +------ 4 char integer 0x8000
125 | |+-------- checksum
126 | +--------- type 6 (data record)
127 +----------- length 3a chars
128 <---------------------- 3a (58 chars) ------------------->
129
130%1B3709T_SEGMENT1108FFFFFFFF
131 ^ ^^ ^- 8 character integer 0xffffffff
132 | |+- 1 character integer 0
133 | +-- type 1 symbol (section definition)
134 +------------ 9 char symbol T_SEGMENT
135
136%2B3AB9T_SEGMENT7Dgcc_compiled$1087hello$c10
137%373829T_SEGMENT80int$t1$r1$$214741080char$t2$r2$0$12710
138%373769T_SEGMENT80long$int$t3$r1$$1080unsigned$int$t4$10
139%373CA9T_SEGMENT80long$unsigned$in1080short$int$t6$r1$10
140%373049T_SEGMENT80long$long$int$t71080short$unsigned$i10
141%373A29T_SEGMENT80long$long$unsign1080signed$char$t10$10
142%373D69T_SEGMENT80unsigned$char$t11080float$t12$r1$4$010
143%373D19T_SEGMENT80double$t13$r1$8$1080long$double$t14$10
144%2734D9T_SEGMENT8Bvoid$t15$151035_main10
145%2F3CA9T_SEGMENT81$1081$1681$1E81$21487main$F110
146%2832F9T_SEGMENT83i$18FFFFFFFC81$1481$214
147%0781010
148
149Turns into
150sac@thepub$ ./objdump -dx -m m68k f
151
152f: file format tekhex
153-----x--- 9/55728 -134219416 Sep 29 15:13 1995 f
154architecture: UNKNOWN!, flags 0x00000010:
155HAS_SYMS
156start address 0x00000000
157SECTION 0 [D00000000] : size 00020000 vma 00000000 align 2**0
158 ALLOC, LOAD
159SECTION 1 [D00008000] : size 00002001 vma 00008000 align 2**0
160
161SECTION 2 [T_SEGMENT] : size ffffffff vma 00000000 align 2**0
162
163SYMBOL TABLE:
16400000000 g T_SEGMENT gcc_compiled$
16500000000 g T_SEGMENT hello$c
16600000000 g T_SEGMENT int$t1$r1$$21474
16700000000 g T_SEGMENT char$t2$r2$0$127
16800000000 g T_SEGMENT long$int$t3$r1$$
16900000000 g T_SEGMENT unsigned$int$t4$
17000000000 g T_SEGMENT long$unsigned$in
17100000000 g T_SEGMENT short$int$t6$r1$
17200000000 g T_SEGMENT long$long$int$t7
17300000000 g T_SEGMENT short$unsigned$i
17400000000 g T_SEGMENT long$long$unsign
17500000000 g T_SEGMENT signed$char$t10$
17600000000 g T_SEGMENT unsigned$char$t1
17700000000 g T_SEGMENT float$t12$r1$4$0
17800000000 g T_SEGMENT double$t13$r1$8$
17900000000 g T_SEGMENT long$double$t14$
18000000000 g T_SEGMENT void$t15$15
18100000000 g T_SEGMENT _main
18200000000 g T_SEGMENT $
18300000000 g T_SEGMENT $
18400000000 g T_SEGMENT $
18500000010 g T_SEGMENT $
18600000000 g T_SEGMENT main$F1
187fcffffff g T_SEGMENT i$1
18800000000 g T_SEGMENT $
18900000010 g T_SEGMENT $
190
191
192RELOCATION RECORDS FOR [D00000000]: (none)
193
194RELOCATION RECORDS FOR [D00008000]: (none)
195
196RELOCATION RECORDS FOR [T_SEGMENT]: (none)
197
198Disassembly of section D00000000:
199...
20000008000 ($+)7ff0 linkw fp,#-4
20100008004 ($+)7ff4 nop
20200008006 ($+)7ff6 movel #99,d0
20300008008 ($+)7ff8 cmpl fp@(-4),d0
2040000800c ($+)7ffc blts 00008014 ($+)8004
2050000800e ($+)7ffe addql #1,fp@(-4)
20600008012 ($+)8002 bras 00008006 ($+)7ff6
20700008014 ($+)8004 unlk fp
20800008016 ($+)8006 rts
209...
210
211*/
212
213static void
214DEFUN_VOID(tekhex_init)
215{
216 unsigned int i;
217 static boolean inited = false;
218 int val;
219 if (inited == false)
220 {
221
222 inited = true;
223
224 for (i = 0; i < CHARS_IN_SET; i++)
225 {
226 hex_value[i] = NOT_HEX;
227 }
228
229 for (i = 0; i < 10; i++)
230 {
231 hex_value[i + '0'] = i;
232
233 }
234 for (i = 0; i < 6; i++)
235 {
236 hex_value[i + 'a'] = i+10;
237 hex_value[i + 'A'] = i+10;
238 }
239 val = 0;
240 for (i = 0; i < 10; i++) {
241 sum_block[i + '0'] = val++;
242 }
243 for (i = 'A'; i <= 'Z'; i++) {
244 sum_block[i] = val++;
245 }
246 sum_block['$'] = val++;
247 sum_block['%'] = val++;
248 sum_block['.'] = val++;
249 sum_block['_'] = val++;
250 for (i = 'a'; i <= 'z'; i++) {
251 sum_block[i] = val++;
252 }
253 }
254}
255
256
257/* The maximum number of bytes on a line is FF */
258#define MAXCHUNK 0xff
259/* The number of bytes we fit onto a line on output */
260#define CHUNK 21
261
262/* We cannot output our tekhexords as we see them, we have to glue them
263 together, this is done in this structure : */
264
265struct tekhex_data_list_struct
266{
267 unsigned char *data;
268 bfd_vma where;
269 bfd_size_type size;
270 struct tekhex_data_list_struct *next;
271
272} ;
273typedef struct tekhex_data_list_struct tekhex_data_list_type;
274
275
276
277#define CHUNK_MASK 0x1fff
278
279struct data_struct {
280 char chunk_data[CHUNK_MASK+1];
281 char chunk_init[CHUNK_MASK+1];
282 bfd_vma vma;
283 struct data_struct *next;
284} ;
285
286typedef struct tekhex_data_struct
287{
288 tekhex_data_list_type *head;
289 unsigned int type;
290 struct tekhex_symbol_struct *symbols;
291 struct data_struct *data;
292} tdata_type;
293
294
295
296#define enda(x) (x->vma + x->size)
297
298
299static bfd_vma
300DEFUN(getvalue,(srcp),
301 char **srcp)
302{
303 char *src = *srcp;
304 bfd_vma value = 0;
305 unsigned int len = hex_value[*src++];
306 if (len == 0) len=16;
307 while (len --) {
308 value = value << 4 | hex_value[*src++];
309 }
310 *srcp = src;
311 return value;
312}
313
314static unsigned int
315DEFUN(getsym,(dstp,srcp),
316 char *dstp AND
317 char **srcp)
318{
319 char *src = *srcp;
320 unsigned int i;
321 unsigned int len = hex_value[*src++];
322 if (len == 0) len=16;
323 for (i = 0; i < len; i++)
324 dstp[i] = src[i];
325 dstp[i] = 0;
326 *srcp = src + i;
327 return len;
328}
329
330struct data_struct *
331DEFUN(find_chunk,(abfd, vma),
332 bfd *abfd AND
333 bfd_vma vma)
334{
335 struct data_struct *d = abfd->tdata.tekhex_data->data;
336 vma &= ~CHUNK_MASK;
337 while (d && (d->vma) != vma)
338 {
339 d = d->next;
340 }
341 if (!d) {
342 char *sname = bfd_alloc(abfd, 12);
343 asection *s;
344
345 /* No chunk for this address, so make one up */
346 d =(struct data_struct *)
347 bfd_alloc(abfd, sizeof(struct data_struct));
348 memset(d->chunk_init, 0, CHUNK_MASK+1);
349 memset(d->chunk_data, 0, CHUNK_MASK+1);
350 d->next = abfd->tdata.tekhex_data->data ;
351 d->vma = vma;
352 abfd->tdata.tekhex_data->data = d;
353 }
354 return d;
355}
356
357DEFUN(insert_byte,(abfd, value, addr),
358 bfd *abfd AND
359 int value AND
360 bfd_vma addr)
361{
362 /* Find the chunk that this byte needs and put it in */
363 struct data_struct *d = find_chunk(abfd, addr);
364 d->chunk_data[addr &CHUNK_MASK] = value;
365 d->chunk_init[addr &CHUNK_MASK] = 1;
366
367}
368/* The first pass is to find the names of all the sections, and see
369 how big the data is */
370static void
371DEFUN(first_phase,(abfd, type, src),
372 bfd *abfd AND
373 char type AND
374 char *src)
375{
376 asection *section = &bfd_abs_section;
377 int len;
378 char sym[17]; /* A symbol can only be 16chars long */
379 switch (type)
380 {
381 case '6':
382 /* Data record - read it and store it */
383 {
384 bfd_vma addr = getvalue(&src);
385 while (*src) {
386 insert_byte(abfd, HEX(src), addr);
387 src+=2;
388 addr++;
389 }
390 }
391
392 return;
393 case '3':
394 /* Symbol record, read the segment */
395 len = getsym(sym, &src);
396 section = bfd_get_section_by_name(abfd, sym);
397 if (section == (asection *)NULL)
398 {
399 char *n = bfd_alloc(abfd, len+1);
400 memcpy(n, sym, len+1);
401 section = bfd_make_section(abfd, n);
402 }
403 while (*src)
404 {
405 switch (*src) {
406 asection *s;
407 case '1': /* section range */
408 src++;
409 section->vma = getvalue(&src);
410 section->_raw_size = getvalue(&src) - section->vma;
411 section->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
412 break;
413
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 tekhex_symbol_type *new =
423 (tekhex_symbol_type *)bfd_alloc(abfd,
424 sizeof(tekhex_symbol_type));
425 char type=(*src);
426 new->symbol.the_bfd = abfd;
427 src++;
428 abfd->symcount++;
429 abfd->flags |= HAS_SYMS;
430 new->prev = abfd->tdata.tekhex_data->symbols;
431 abfd->tdata.tekhex_data->symbols = new;
432 len = getsym(sym, &src);
433 new->symbol.name = bfd_alloc(abfd,len+1);
434 memcpy((char *)(new->symbol.name), sym, len+1);
435 new->symbol.section = section ;
436 if (type <= '4')
437 new->symbol.flags = (BSF_GLOBAL|BSF_EXPORT);
438 else
439 new->symbol.flags = BSF_LOCAL;
440 new->symbol.value = getvalue(&src) - section->vma;
441 }
442 }
443 }
444 }
445}
446
447
448/* Pass over an tekhex, calling one of the above functions on each
449 record. */
450
451static void
452 DEFUN(pass_over,(abfd, func),
453 bfd *abfd AND
454 void (*func) PARAMS ((bfd *, char, char *)))
455{
456 unsigned int chars_on_line;
457 boolean eof = false;
458
459 /* To the front of the file */
460 bfd_seek(abfd, (file_ptr)0, SEEK_SET);
461 while (eof == false)
462 {
463 char buffer[MAXCHUNK];
464 char *src = buffer;
465 char type;
466 bfd_vma address = 0;
467
468 /* Find first '%' */
469 eof = (boolean)(bfd_read(src, 1, 1, abfd) != 1);
470 while (*src!= '%' && !eof) {
471 eof = (boolean)(bfd_read(src, 1, 1, abfd) != 1);
472 }
473 if (eof) break;
474 src++;
475
476
477 /* Fetch the type and the length and the checksum */
478 bfd_read(src, 1, 5, abfd);
479
480 type = src[2];
481
482 if (!ISHEX (src[0]) || !ISHEX (src[1]))
483 break;
484
485 chars_on_line = HEX(src) - 5; /* Already read five char */
486
487 bfd_read(src, 1 , chars_on_line , abfd);
488 src[chars_on_line] = 0; /* put a null at the end */
489
490
491
492 func(abfd, type, src);
493 }
494
495}
496
497
498
499
500unsigned int
501DEFUN(tekhex_get_symtab,(abfd, table),
502 bfd *abfd AND
503 asymbol **table)
504{
505 tekhex_symbol_type *p = abfd->tdata.tekhex_data->symbols;
506 unsigned int c = bfd_get_symcount(abfd) ;
507 table[c]= 0;
508 while (p) {
509 table[--c] = &(p->symbol);
510 p = p->prev;
511 }
512
513 return bfd_get_symcount(abfd);
514}
515
516unsigned int
517DEFUN(tekhex_get_symtab_upper_bound,(abfd),
518 bfd *abfd)
519{
520 return (abfd->symcount+1) * (sizeof(struct tekhex_asymbol_struct *));
521
522}
523
524static boolean
525DEFUN(tekhex_mkobject, (abfd),
526 bfd *abfd)
527{
528 tdata_type *tdata = (tdata_type *)bfd_alloc(abfd, sizeof(tdata_type));
529 abfd->tdata.tekhex_data = tdata;
530 tdata->type = 1;
531 tdata->head = (tekhex_data_list_type *)NULL;
532 tdata->symbols = (struct tekhex_symbol_struct *)NULL;
533tdata->data = (struct data_struct *)NULL;
534 return true;
535
536}
537
538/*
539 Return true if the file looks like it's in TekHex format. Just look
540 for a percent sign and some hex digits */
541
542
543static bfd_target *
544DEFUN(tekhex_object_p, (abfd),
545 bfd *abfd)
546{
547 char b[4];
548 asection *section;
549 tekhex_init();
550
551 bfd_seek(abfd, (file_ptr)0, SEEK_SET);
552 bfd_read(b, 1, 4, abfd);
553
554 if (b[0] != '%' || !ISHEX(b[1]) || !ISHEX(b[2]) || !ISHEX(b[3]))
555 return (bfd_target*) NULL;
556
557 tekhex_mkobject(abfd);
558
559 pass_over(abfd, first_phase);
560 return abfd->xvec;
561}
562
563
564static boolean
565DEFUN(move_section_contents,(abfd, section, locationp, offset,count,
566 get),
567
568 bfd *abfd AND
569 asection *section AND
570 PTR locationp AND
571 file_ptr offset AND
572 bfd_size_type count AND
573 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 = (struct data_struct *)NULL;
579 for (addr = section->vma; count != 0; count --, addr++)
580 {
581
582 bfd_vma chunk_number = addr & ~ CHUNK_MASK; /* Get high bits of address */
583 bfd_vma low_bits = addr & CHUNK_MASK;
584 if (chunk_number != prev_number)
585 {
586 /* Different chunk, so move pointer */
587 d = find_chunk(abfd, chunk_number);
588 }
589
590 if (get) {
591 if (d->chunk_init[low_bits])
592 {
593 *location = d->chunk_data[low_bits];
594 }
595 else
596 {
597 *location = 0;
598 }
599 }
600 else {
601 d->chunk_data[low_bits] = *location ;
602 d->chunk_init[low_bits] = (*location != 0);
603 }
604
605
606 location ++;
607
608 }
609
610}
611static boolean
612DEFUN(tekhex_get_section_contents,(abfd, section, locationp, offset, count),
613 bfd *abfd AND
614 asection *section AND
615 PTR locationp AND
616 file_ptr offset AND
617 bfd_size_type count)
618{
619 if (section->flags & (SEC_LOAD | SEC_ALLOC))
620 {
621 move_section_contents(abfd, section, locationp, offset, count, true);
622 return true;
623 }
624 else return false;
625}
626
627
628
629boolean
630DEFUN(tekhex_set_arch_mach,(abfd, arch, machine),
631 bfd *abfd AND
632 enum bfd_architecture arch AND
633 unsigned long machine)
634{
635 return bfd_default_set_arch_mach(abfd, arch, machine);
636}
637
638
639/* we have to save up all the Tekhexords for a splurge before output,
640 */
641
642static boolean
643DEFUN(tekhex_set_section_contents,(abfd, section, locationp, offset, bytes_to_do),
644 bfd *abfd AND
645 sec_ptr section AND
646 PTR locationp AND
647 file_ptr offset AND
648 bfd_size_type bytes_to_do)
649{
650
651 if (abfd->output_has_begun == false) {
652 /* The first time around, allocate enough sections to hold all the chunks */
653 asection *s = abfd->sections;
654 bfd_vma vma;
655 for (s = abfd->sections; s ; s = s->next) {
656 if (s->flags & SEC_LOAD) {
657 for (vma = s->vma & ~CHUNK_MASK;
658 vma < s->vma + s->_raw_size;
659 vma += CHUNK_MASK)
660 find_chunk(abfd, vma);
661 }
662 }
663
664 }
665 if (section->flags & (SEC_LOAD | SEC_ALLOC))
666 {
667 move_section_contents(abfd, section, locationp, offset, bytes_to_do, false);
668 return true;
669 }
670 else return false;
671
672}
673
674
675static void
676DEFUN(writevalue,(dst, value),
677 char **dst AND
678 bfd_vma value)
679{
680 char *p = *dst;
681 int len ;
682 int shift;
683 for (len = 8, shift = 28; shift ; shift-=4, len--)
684 {
685 if ((value>>shift) & 0xf) {
686 *p ++ = len + '0';
687 while (len) {
688 *p ++ = digs[(value>>shift) &0xf];
689 shift-=4;
690 len --;
691 }
692 *dst = p;
693 return;
694
695 }
696 }
697 *p++ = '1';
698 *p++ = '0';
699 *dst = p;
700}
701
702static void
703DEFUN(writesym,(dst, sym),
704 char **dst AND
705 CONST char *sym)
706{
707 char *p = *dst;
708 int len = (sym?strlen(sym):0);
709 if (len >= 16) {
710 *p++ = '0';
711 len = 16;
712 }
713
714 else {
715 if (len == 0) {
716 *p++ = '1';
717 sym = "$";
718 len=1;
719 }
720 else
721 {
722 *p++ = digs[len];
723 }
724 }
725
726 while (len--) {
727 *p++ = *sym++;
728 }
729 *dst = p;
730}
731
732static void
733DEFUN(out,(abfd, type, start, end),
734 bfd *abfd AND
735 char type AND
736 char *start AND
737 char *end)
738{
739 int sum = 0;
740 char *s;
741 char front[6];
742 front[0] = '%';
743 TOHEX(front+1, end - start + 5);
744 front[3] = type;
745
746 for (s = start; s < end; s++) {
747 sum += sum_block[*s];
748 }
749
750
751 sum += sum_block[front[1]];/* length */
752 sum += sum_block[front[2]];
753 sum += sum_block[front[3]];/* type */
754 TOHEX(front+4, sum);
755 bfd_write(front, 1, 6,abfd);
756 end[0] = '\n';
757 bfd_write(start, 1,end-start+1,abfd);
758
759}
760static boolean
761DEFUN(tekhex_write_object_contents,(abfd),
762 bfd *abfd)
763{
764 int bytes_written;
765 char buffer[100];
766 asymbol **p;
767 tdata_type *tdata = abfd->tdata.tekhex_data;
768 tekhex_data_list_type *list;
769 asection *s;
770 struct data_struct *d;
771 bytes_written = 0;
772
773 /* And the raw data */
774 for (d = abfd->tdata.tekhex_data->data;
775 d != (struct data_struct *)NULL;
776 d = d->next)
777 {
778 int low;
779
780 CONST int span=32;
781 int addr;
782 /* Write it in blocks of 32 bytes */
783
784 for (addr = 0; addr < CHUNK_MASK + 1; addr+=span)
785 {
786 int need = 0;
787 /* Check to see if necessary */
788 for (low = 0; !need && low < span; low++) {
789 if (d->chunk_init[addr + low]) need = 1;
790 }
791 if (need){
792 char * dst = buffer;
793 writevalue(&dst, addr + d->vma);
794 for (low = 0; low <span; low++) {
795 TOHEX(dst, d->chunk_data[addr + low]);
796 dst+=2;
797 }
798 out(abfd, '6', buffer, dst);
799 }
800 }
801 }
802 /* write all the section headers for the sections */
803 for (s = abfd->sections ; s != (asection *)NULL ; s = s->next)
804 {
805 char *dst = buffer;
806 writesym(&dst, s->name);
807 *dst++ = '1';
808 writevalue(&dst, s->vma);
809 writevalue(&dst, s->vma + s->_raw_size);
810 out(abfd, '3',buffer, dst);
811 }
812
813 /* And the symbols */
814 for (p = abfd->outsymbols; *p; p++) {
815 int section_code = bfd_decode_symclass (*p);
816 if (section_code != '?') { /* do not include debug symbols */
817 asymbol *s = *p;
818 char *dst = buffer;
819 writesym(&dst, s->section->name);
820
821 switch(section_code) {
822 case 'A':
823 *dst++ = '2';
824 break;
825 case 'a':
826 *dst++ = '6';
827 break;
828 case 'D':
829 case 'B':
830 case 'O':
831 *dst++ = '4';
832 break;
833 case 'd':
834 case 'b':
835 case 'o':
836 *dst++ = '8';
837 break;
838 case 'T':
839 *dst++ = '3';
840 break;
841 case 't':
842 *dst++ = '7';
843 break;
844 case 'C':
845 case 'U':
846 bfd_error=wrong_format;
847 return false;
848 }
849
850 writesym(&dst, s->name);
851 writevalue(&dst, s->value + s->section->vma);
852 out(abfd, '3', buffer, dst);
853 }
854 }
855
856
857 /* And the terminator */
858 bfd_write("%7081010\n", 1,9 , abfd);
859return true;
860}
861
862
863static int
864DEFUN(tekhex_sizeof_headers,(abfd, exec),
865 bfd *abfd AND
866 boolean exec)
867{
868return 0;
869}
870
871static asymbol *
872DEFUN(tekhex_make_empty_symbol, (abfd),
873 bfd*abfd)
874{
875 tekhex_symbol_type *new=
876 (tekhex_symbol_type *)bfd_zalloc (abfd, sizeof (struct tekhex_symbol_struct));
877 new->symbol.the_bfd = abfd;
878 new->prev = (struct tekhex_symbol_struct *)NULL;
879 return &(new->symbol);
880}
881
882static void
883DEFUN(tekhex_print_symbol,(ignore_abfd, filep, symbol, how),
884 bfd *ignore_abfd AND
885 PTR filep AND
886 asymbol *symbol AND
887 bfd_print_symbol_type how)
888{
889 FILE *file = (FILE *)filep;
890 switch (how) {
891 case bfd_print_symbol_name:
892 fprintf(file, "%s", symbol->name);
893 break;
894 case bfd_print_symbol_more:
895 break;
896 case bfd_print_symbol_nm:
897 {
898 int section_code = bfd_decode_symclass (symbol);
899
900 if (section_code == 'U')
901 fprintf(file, " ");
902 fprintf_vma(file, symbol->value+symbol->section->vma);
903 if (section_code == '?')
904 {
905 fprintf(file," ?");
906 }
907 else
908 fprintf(file," %c", section_code);
909 if (symbol->name)
910 fprintf(file," %s", symbol->name);
911 }
912 break;
913 case bfd_print_symbol_all:
914 {
915 CONST char *section_name = symbol->section->name;
916 bfd_print_symbol_vandf((PTR) file, symbol);
917
918
919 fprintf(file, " %-5s %s",
920 section_name,
921 symbol->name);
922 }
923 }
924}
925
926#define FOO PROTO
927#define tekhex_new_section_hook (FOO(boolean, (*), (bfd *, asection *)))bfd_true
928#define tekhex_get_reloc_upper_bound (FOO(unsigned int, (*),(bfd*, asection *)))bfd_false
929#define tekhex_canonicalize_reloc (FOO(unsigned int, (*),(bfd*,asection *, arelent **, asymbol **))) bfd_0
930
931
932#define tekhex_openr_next_archived_file (FOO(bfd *, (*), (bfd*,bfd*))) bfd_nullvoidptr
933#define tekhex_find_nearest_line (FOO(boolean, (*),(bfd*,asection*,asymbol**,bfd_vma, CONST char**, CONST char**, unsigned int *))) bfd_false
934#define tekhex_generic_stat_arch_elt (FOO(int, (*), (bfd *,struct stat *))) bfd_0
935
936
937#define tekhex_core_file_failing_command (char *(*)())(bfd_nullvoidptr)
938#define tekhex_core_file_failing_signal (int (*)())bfd_0
939#define tekhex_core_file_matches_executable_p (FOO(boolean, (*),(bfd*, bfd*)))bfd_false
940#define tekhex_slurp_armap bfd_true
941#define tekhex_slurp_extended_name_table bfd_true
942#define tekhex_truncate_arname (void (*)())bfd_nullvoidptr
943#define tekhex_write_armap (FOO( boolean, (*),(bfd *, unsigned int, struct orl *, unsigned int, int))) bfd_nullvoidptr
944#define tekhex_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr
945#define tekhex_close_and_cleanup bfd_generic_close_and_cleanup
946#define tekhex_bfd_debug_info_start bfd_void
947#define tekhex_bfd_debug_info_end bfd_void
948#define tekhex_bfd_debug_info_accumulate (FOO(void, (*), (bfd *, asection *))) bfd_void
949#define tekhex_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
950#define tekhex_bfd_relax_section bfd_generic_relax_section
951bfd_target tekhex_vec =
952{
953 "tekhex", /* name */
954 bfd_target_tekhex_flavour,
955 true, /* target byte order */
956 true, /* target headers byte order */
957 ( EXEC_P | /* object flags */
958 HAS_SYMS | HAS_LOCALS | DYNAMIC | 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 1, /* minimum alignment */
965 _do_getb64, _do_putb64, _do_getb32,
966 _do_putb32, _do_getb16, _do_putb16, /* data */
967 _do_getb64, _do_putb64, _do_getb32,
968 _do_putb32, _do_getb16, _do_putb16, /* hdrs */
969
970 {
971 _bfd_dummy_target,
972 tekhex_object_p, /* bfd_check_format */
973 (struct bfd_target *(*)()) bfd_nullvoidptr,
974 (struct bfd_target *(*)()) bfd_nullvoidptr,
975 },
976 {
977 bfd_false,
978 tekhex_mkobject,
979 _bfd_generic_mkarchive,
980 bfd_false,
981 },
982 { /* bfd_write_contents */
983 bfd_false,
984 tekhex_write_object_contents,
985 _bfd_write_archive_contents,
986 bfd_false,
987 },
988 JUMP_TABLE(tekhex)
989 };
990
GDB Binutils - Deliverables
This page took 0.0596 seconds and 4 git commands to generate.