projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* elflink.h (elf_bfd_final_link): Remove unused variables rel_hash
[deliverable/binutils-gdb.git] / bfd / tekhex.c
CommitLineData
252b5132 1/* BFD backend for Extended Tektronix Hex Format objects.
7442e600
ILT		 2 Copyright (C) 1992, 93, 94, 95, 96, 97, 98, 1999
3 Free Software Foundation, Inc.
252b5132
RH		 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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#include "libiberty.h"
76
77typedef struct
78 {
79 bfd_vma low;
80 bfd_vma high;
81 } addr_range_type;
82
83typedef struct tekhex_symbol_struct
84 {
85
86 asymbol symbol;
87 struct tekhex_symbol_struct *prev;
88
89 } tekhex_symbol_type;
90
91static const char digs[] = "0123456789ABCDEF";
92
93static char sum_block[256];
94
95#define NOT_HEX 20
96#define NIBBLE(x) hex_value(x)
97#define HEX(buffer) ((NIBBLE((buffer)[0])<<4) + NIBBLE((buffer)[1]))
98#define TOHEX(d,x) \
99(d)[1] = digs[(x) & 0xf]; \
100(d)[0] = digs[((x)>>4)&0xf];
101#define ISHEX(x) hex_p(x)
102
103static void tekhex_init PARAMS ((void));
104static bfd_vma getvalue PARAMS ((char **));
105static void tekhex_print_symbol
106 PARAMS ((bfd *, PTR, asymbol *, bfd_print_symbol_type));
107static void tekhex_get_symbol_info PARAMS ((bfd *, asymbol *, symbol_info *));
108static asymbol *tekhex_make_empty_symbol PARAMS ((bfd *));
109static int tekhex_sizeof_headers PARAMS ((bfd *, boolean));
110static boolean tekhex_write_object_contents PARAMS ((bfd *));
111static void out PARAMS ((bfd *, int, char *, char *));
112static void writesym PARAMS ((char **, CONST char *));
113static void writevalue PARAMS ((char **, bfd_vma));
114static boolean tekhex_set_section_contents
115 PARAMS ((bfd*, sec_ptr, PTR, file_ptr, bfd_size_type));
116static boolean tekhex_set_arch_mach
117 PARAMS ((bfd *, enum bfd_architecture, unsigned long));
118static boolean tekhex_get_section_contents
119 PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
120static void move_section_contents
121 PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type, boolean));
122static const bfd_target *tekhex_object_p PARAMS ((bfd *));
123static boolean tekhex_mkobject PARAMS ((bfd *));
124static long tekhex_get_symtab_upper_bound PARAMS ((bfd *));
125static long tekhex_get_symtab PARAMS ((bfd *, asymbol **));
126static void pass_over PARAMS ((bfd *, void (*)(bfd*, int, char *)));
127static void first_phase PARAMS ((bfd *, int, char *));
128static void insert_byte PARAMS ((bfd *, int, bfd_vma));
129static struct data_struct *find_chunk PARAMS ((bfd *, bfd_vma));
130static unsigned int getsym PARAMS ((char *, char **));
131
132/*
133Here's an example
134%3A6C6480004E56FFFC4E717063B0AEFFFC6D0652AEFFFC60F24E5E4E75
135%1B3709T_SEGMENT1108FFFFFFFF
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%07 8 10 10
148
149explanation:
150%3A6C6480004E56FFFC4E717063B0AEFFFC6D0652AEFFFC60F24E5E4E75
151 ^ ^^ ^ ^-data
152 | || +------ 4 char integer 0x8000
153 | |+-------- checksum
154 | +--------- type 6 (data record)
155 +----------- length 3a chars
156 <---------------------- 3a (58 chars) ------------------->
157
158%1B3709T_SEGMENT1108FFFFFFFF
159 ^ ^^ ^- 8 character integer 0xffffffff
160 | |+- 1 character integer 0
161 | +-- type 1 symbol (section definition)
162 +------------ 9 char symbol T_SEGMENT
163
164%2B3AB9T_SEGMENT7Dgcc_compiled$1087hello$c10
165%373829T_SEGMENT80int$t1$r1$$214741080char$t2$r2$0$12710
166%373769T_SEGMENT80long$int$t3$r1$$1080unsigned$int$t4$10
167%373CA9T_SEGMENT80long$unsigned$in1080short$int$t6$r1$10
168%373049T_SEGMENT80long$long$int$t71080short$unsigned$i10
169%373A29T_SEGMENT80long$long$unsign1080signed$char$t10$10
170%373D69T_SEGMENT80unsigned$char$t11080float$t12$r1$4$010
171%373D19T_SEGMENT80double$t13$r1$8$1080long$double$t14$10
172%2734D9T_SEGMENT8Bvoid$t15$151035_main10
173%2F3CA9T_SEGMENT81$1081$1681$1E81$21487main$F110
174%2832F9T_SEGMENT83i$18FFFFFFFC81$1481$214
175%0781010
176
177Turns into
178sac@thepub$ ./objdump -dx -m m68k f
179
180f: file format tekhex
181-----x--- 9/55728 -134219416 Sep 29 15:13 1995 f
182architecture: UNKNOWN!, flags 0x00000010:
183HAS_SYMS
184start address 0x00000000
185SECTION 0 [D00000000] : size 00020000 vma 00000000 align 2**0
186 ALLOC, LOAD
187SECTION 1 [D00008000] : size 00002001 vma 00008000 align 2**0
188
189SECTION 2 [T_SEGMENT] : size ffffffff vma 00000000 align 2**0
190
191SYMBOL TABLE:
19200000000 g T_SEGMENT gcc_compiled$
19300000000 g T_SEGMENT hello$c
19400000000 g T_SEGMENT int$t1$r1$$21474
19500000000 g T_SEGMENT char$t2$r2$0$127
19600000000 g T_SEGMENT long$int$t3$r1$$
19700000000 g T_SEGMENT unsigned$int$t4$
19800000000 g T_SEGMENT long$unsigned$in
19900000000 g T_SEGMENT short$int$t6$r1$
20000000000 g T_SEGMENT long$long$int$t7
20100000000 g T_SEGMENT short$unsigned$i
20200000000 g T_SEGMENT long$long$unsign
20300000000 g T_SEGMENT signed$char$t10$
20400000000 g T_SEGMENT unsigned$char$t1
20500000000 g T_SEGMENT float$t12$r1$4$0
20600000000 g T_SEGMENT double$t13$r1$8$
20700000000 g T_SEGMENT long$double$t14$
20800000000 g T_SEGMENT void$t15$15
20900000000 g T_SEGMENT _main
21000000000 g T_SEGMENT $
21100000000 g T_SEGMENT $
21200000000 g T_SEGMENT $
21300000010 g T_SEGMENT $
21400000000 g T_SEGMENT main$F1
215fcffffff g T_SEGMENT i$1
21600000000 g T_SEGMENT $
21700000010 g T_SEGMENT $
218
219
220RELOCATION RECORDS FOR [D00000000]: (none)
221
222RELOCATION RECORDS FOR [D00008000]: (none)
223
224RELOCATION RECORDS FOR [T_SEGMENT]: (none)
225
226Disassembly of section D00000000:
227...
22800008000 ($+)7ff0 linkw fp,#-4
22900008004 ($+)7ff4 nop
23000008006 ($+)7ff6 movel #99,d0
23100008008 ($+)7ff8 cmpl fp@(-4),d0
2320000800c ($+)7ffc blts 00008014 ($+)8004
2330000800e ($+)7ffe addql #1,fp@(-4)
23400008012 ($+)8002 bras 00008006 ($+)7ff6
23500008014 ($+)8004 unlk fp
23600008016 ($+)8006 rts
237...
238
239*/
240
241static void
242tekhex_init ()
243{
244 unsigned int i;
245 static boolean inited = false;
246 int val;
247
248 if (inited == false)
249 {
250 inited = true;
251 hex_init ();
252 val = 0;
253 for (i = 0; i < 10; i++)
254 {
255 sum_block[i + '0'] = val++;
256 }
257 for (i = 'A'; i <= 'Z'; i++)
258 {
259 sum_block[i] = val++;
260 }
261 sum_block['$'] = val++;
262 sum_block['%'] = val++;
263 sum_block['.'] = val++;
264 sum_block['_'] = val++;
265 for (i = 'a'; i <= 'z'; i++)
266 {
267 sum_block[i] = val++;
268 }
269 }
270}
271
272/* The maximum number of bytes on a line is FF */
273#define MAXCHUNK 0xff
274/* The number of bytes we fit onto a line on output */
275#define CHUNK 21
276
277/* We cannot output our tekhexords as we see them, we have to glue them
278 together, this is done in this structure : */
279
280struct tekhex_data_list_struct
281{
282 unsigned char *data;
283 bfd_vma where;
284 bfd_size_type size;
285 struct tekhex_data_list_struct *next;
286
287};
288typedef struct tekhex_data_list_struct tekhex_data_list_type;
289
290#define CHUNK_MASK 0x1fff
291
292struct data_struct
293 {
294 char chunk_data[CHUNK_MASK + 1];
295 char chunk_init[CHUNK_MASK + 1];
296 bfd_vma vma;
297 struct data_struct *next;
298 };
299
300typedef struct tekhex_data_struct
301{
302 tekhex_data_list_type *head;
303 unsigned int type;
304 struct tekhex_symbol_struct *symbols;
305 struct data_struct *data;
306} tdata_type;
307
308#define enda(x) (x->vma + x->size)
309
310static bfd_vma
311getvalue (srcp)
312 char **srcp;
313{
314 char *src = *srcp;
315 bfd_vma value = 0;
316 unsigned int len = hex_value(*src++);
317
318 if (len == 0)
319 len = 16;
320 while (len--)
321 {
322 value = value << 4 | hex_value(*src++);
323 }
324 *srcp = src;
325 return value;
326}
327
328static unsigned int
329getsym (dstp, srcp)
330 char *dstp;
331 char **srcp;
332{
333 char *src = *srcp;
334 unsigned int i;
335 unsigned int len = hex_value(*src++);
336
337 if (len == 0)
338 len = 16;
339 for (i = 0; i < len; i++)
340 dstp[i] = src[i];
341 dstp[i] = 0;
342 *srcp = src + i;
343 return len;
344}
345
346static struct data_struct *
347find_chunk (abfd, vma)
348 bfd *abfd;
349 bfd_vma vma;
350{
351 struct data_struct *d = abfd->tdata.tekhex_data->data;
352
353 vma &= ~CHUNK_MASK;
354 while (d && (d->vma) != vma)
355 {
356 d = d->next;
357 }
358 if (!d)
359 {
360 char *sname = bfd_alloc (abfd, 12);
361
362 /* No chunk for this address, so make one up */
363 d = (struct data_struct *)
364 bfd_alloc (abfd, sizeof (struct data_struct));
365
366 if (!sname || !d)
367 return NULL;
368
369 memset (d->chunk_init, 0, CHUNK_MASK + 1);
370 memset (d->chunk_data, 0, CHUNK_MASK + 1);
371 d->next = abfd->tdata.tekhex_data->data;
372 d->vma = vma;
373 abfd->tdata.tekhex_data->data = d;
374 }
375 return d;
376}
377
378static void
379insert_byte (abfd, value, addr)
380 bfd *abfd;
381 int value;
382 bfd_vma addr;
383{
384 /* Find the chunk that this byte needs and put it in */
385 struct data_struct *d = find_chunk (abfd, addr);
386
387 d->chunk_data[addr & CHUNK_MASK] = value;
388 d->chunk_init[addr & CHUNK_MASK] = 1;
389}
390
391/* The first pass is to find the names of all the sections, and see
392 how big the data is */
393static void
394first_phase (abfd, type, src)
395 bfd *abfd;
396 int type;
397 char *src;
398{
399 asection *section = bfd_abs_section_ptr;
400 int len;
401 char sym[17]; /* A symbol can only be 16chars long */
402
403 switch (type)
404 {
405 case '6':
406 /* Data record - read it and store it */
407 {
408 bfd_vma addr = getvalue (&src);
409
410 while (*src)
411 {
412 insert_byte (abfd, HEX (src), addr);
413 src += 2;
414 addr++;
415 }
416 }
417
418 return;
419 case '3':
420 /* Symbol record, read the segment */
421 len = getsym (sym, &src);
422 section = bfd_get_section_by_name (abfd, sym);
423 if (section == (asection *) NULL)
424 {
425 char *n = bfd_alloc (abfd, len + 1);
426
427 if (!n)
428 abort(); /* FIXME */
429 memcpy (n, sym, len + 1);
430 section = bfd_make_section (abfd, n);
431 }
432 while (*src)
433 {
434 switch (*src)
435 {
436 case '1': /* section range */
437 src++;
438 section->vma = getvalue (&src);
439 section->_raw_size = getvalue (&src) - section->vma;
440 section->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
441 break;
442 case '0':
443 case '2':
444 case '3':
445 case '4':
446 case '6':
447 case '7':
448 case '8':
449 /* Symbols, add to section */
450 {
451 tekhex_symbol_type *new =
452 (tekhex_symbol_type *) bfd_alloc (abfd,
453 sizeof (tekhex_symbol_type));
454 char type = (*src);
455
456 if (!new)
457 abort(); /* FIXME */
458 new->symbol.the_bfd = abfd;
459 src++;
460 abfd->symcount++;
461 abfd->flags |= HAS_SYMS;
462 new->prev = abfd->tdata.tekhex_data->symbols;
463 abfd->tdata.tekhex_data->symbols = new;
464 len = getsym (sym, &src);
465 new->symbol.name = bfd_alloc (abfd, len + 1);
466 if (!new->symbol.name)
467 abort(); /* FIXME */
468 memcpy ((char *) (new->symbol.name), sym, len + 1);
469 new->symbol.section = section;
470 if (type <= '4')
471 new->symbol.flags = (BSF_GLOBAL | BSF_EXPORT);
472 else
473 new->symbol.flags = BSF_LOCAL;
474 new->symbol.value = getvalue (&src) - section->vma;
475 }
476 }
477 }
478 }
479}
480
481/* Pass over an tekhex, calling one of the above functions on each
482 record. */
483
484static void
485pass_over (abfd, func)
486 bfd *abfd;
487 void (*func) PARAMS ((bfd *, int, char *));
488{
489 unsigned int chars_on_line;
490 boolean eof = false;
491
492 /* To the front of the file */
493 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
494 abort ();
495 while (eof == false)
496 {
497 char buffer[MAXCHUNK];
498 char *src = buffer;
499 char type;
500
501 /* Find first '%' */
502 eof = (boolean) (bfd_read (src, 1, 1, abfd) != 1);
503 while (*src != '%' && !eof)
504 {
505 eof = (boolean) (bfd_read (src, 1, 1, abfd) != 1);
506 }
507 if (eof)
508 break;
509 src++;
510
511 /* Fetch the type and the length and the checksum */
512 if (bfd_read (src, 1, 5, abfd) != 5)
513 abort (); /* FIXME */
514
515 type = src[2];
516
517 if (!ISHEX (src[0]) || !ISHEX (src[1]))
518 break;
519
520 chars_on_line = HEX (src) - 5; /* Already read five char */
521
522 if (bfd_read (src, 1, chars_on_line, abfd) != chars_on_line)
523 abort (); /* FIXME */
524 src[chars_on_line] = 0; /* put a null at the end */
525
526 func (abfd, type, src);
527 }
528
529}
530
531static long
532tekhex_get_symtab (abfd, table)
533 bfd *abfd;
534 asymbol **table;
535{
536 tekhex_symbol_type *p = abfd->tdata.tekhex_data->symbols;
537 unsigned int c = bfd_get_symcount (abfd);
538
539 table[c] = 0;
540 while (p)
541 {
542 table[--c] = &(p->symbol);
543 p = p->prev;
544 }
545
546 return bfd_get_symcount (abfd);
547}
548
549static long
550tekhex_get_symtab_upper_bound (abfd)
551 bfd *abfd;
552{
553 return (abfd->symcount + 1) * (sizeof (struct tekhex_asymbol_struct *));
554
555}
556
557static boolean
558tekhex_mkobject (abfd)
559 bfd *abfd;
560{
561 tdata_type *tdata = (tdata_type *) bfd_alloc (abfd, sizeof (tdata_type));
562
563 if (!tdata)
564 return false;
565 abfd->tdata.tekhex_data = tdata;
566 tdata->type = 1;
567 tdata->head = (tekhex_data_list_type *) NULL;
568 tdata->symbols = (struct tekhex_symbol_struct *) NULL;
569 tdata->data = (struct data_struct *) NULL;
570 return true;
571}
572
573/*
574 Return true if the file looks like it's in TekHex format. Just look
575 for a percent sign and some hex digits */
576
577static const bfd_target *
578tekhex_object_p (abfd)
579 bfd *abfd;
580{
581 char b[4];
582
583 tekhex_init ();
584
585 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
586 || bfd_read (b, 1, 4, abfd) != 4)
587 return NULL;
588
589 if (b[0] != '%' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3]))
590 return (const bfd_target *) NULL;
591
592 tekhex_mkobject (abfd);
593
594 pass_over (abfd, first_phase);
595 return abfd->xvec;
596}
597
598static void
599move_section_contents (abfd, section, locationp, offset, count, get)
600 bfd *abfd;
601 asection *section;
602 PTR locationp;
7442e600 603 file_ptr offset ATTRIBUTE_UNUSED;
252b5132
RH		 604 bfd_size_type count;
605 boolean get;
606{
607 bfd_vma addr;
608 char *location = (char *) locationp;
609 bfd_vma prev_number = 1; /* Nothing can have this as a high bit*/
610 struct data_struct *d = (struct data_struct *) NULL;
611
612 for (addr = section->vma; count != 0; count--, addr++)
613 {
614
615 bfd_vma chunk_number = addr & ~CHUNK_MASK; /* Get high bits of address */
616 bfd_vma low_bits = addr & CHUNK_MASK;
617
618 if (chunk_number != prev_number)
619 {
620 /* Different chunk, so move pointer */
621 d = find_chunk (abfd, chunk_number);
622 }
623
624 if (get)
625 {
626 if (d->chunk_init[low_bits])
627 {
628 *location = d->chunk_data[low_bits];
629 }
630 else
631 {
632 *location = 0;
633 }
634 }
635 else
636 {
637 d->chunk_data[low_bits] = *location;
638 d->chunk_init[low_bits] = (*location != 0);
639 }
640
641 location++;
642
643 }
644
645}
646
647static boolean
648tekhex_get_section_contents (abfd, section, locationp, offset, count)
649 bfd *abfd;
650 asection *section;
651 PTR locationp;
652 file_ptr offset;
653 bfd_size_type count;
654{
655 if (section->flags & (SEC_LOAD | SEC_ALLOC))
656 {
657 move_section_contents (abfd, section, locationp, offset, count, true);
658 return true;
659 }
660 else
661 return false;
662}
663
664static boolean
665tekhex_set_arch_mach (abfd, arch, machine)
666 bfd *abfd;
667 enum bfd_architecture arch;
668 unsigned long machine;
669{
670 return bfd_default_set_arch_mach (abfd, arch, machine);
671}
672
673/* we have to save up all the Tekhexords for a splurge before output,
674 */
675
676static boolean
677tekhex_set_section_contents (abfd, section, locationp, offset, bytes_to_do)
678 bfd *abfd;
679 sec_ptr section;
680 PTR locationp;
681 file_ptr offset;
682 bfd_size_type bytes_to_do;
683{
684
685 if (abfd->output_has_begun == false)
686 {
687 /* The first time around, allocate enough sections to hold all the chunks */
688 asection *s = abfd->sections;
689 bfd_vma vma;
690
691 for (s = abfd->sections; s; s = s->next)
692 {
693 if (s->flags & SEC_LOAD)
694 {
695 for (vma = s->vma & ~CHUNK_MASK;
696 vma < s->vma + s->_raw_size;
697 vma += CHUNK_MASK)
698 find_chunk (abfd, vma);
699 }
700 }
701
702 }
703 if (section->flags & (SEC_LOAD | SEC_ALLOC))
704 {
705 move_section_contents (abfd, section, locationp, offset, bytes_to_do, false);
706 return true;
707 }
708 else
709 return false;
710
711}
712
713static void
714writevalue (dst, value)
715 char **dst;
716 bfd_vma value;
717{
718 char *p = *dst;
719 int len;
720 int shift;
721
722 for (len = 8, shift = 28; shift; shift -= 4, len--)
723 {
724 if ((value >> shift) & 0xf)
725 {
726 *p++ = len + '0';
727 while (len)
728 {
729 *p++ = digs[(value >> shift) & 0xf];
730 shift -= 4;
731 len--;
732 }
733 *dst = p;
734 return;
735
736 }
737 }
738 *p++ = '1';
739 *p++ = '0';
740 *dst = p;
741}
742
743static void
744writesym (dst, sym)
745 char **dst;
746 CONST char *sym;
747{
748 char *p = *dst;
749 int len = (sym ? strlen (sym) : 0);
750
751 if (len >= 16)
752 {
753 *p++ = '0';
754 len = 16;
755 }
756
757 else
758 {
759 if (len == 0)
760 {
761 *p++ = '1';
762 sym = "$";
763 len = 1;
764 }
765 else
766 {
767 *p++ = digs[len];
768 }
769 }
770
771 while (len--)
772 {
773 *p++ = *sym++;
774 }
775 *dst = p;
776}
777
778static void
779out (abfd, type, start, end)
780 bfd *abfd;
781 int type;
782 char *start;
783 char *end;
784{
785 int sum = 0;
786 char *s;
787 char front[6];
788 bfd_size_type wrlen;
789
790 front[0] = '%';
791 TOHEX (front + 1, end - start + 5);
792 front[3] = type;
793
794 for (s = start; s < end; s++)
795 {
796 sum += sum_block[(unsigned char) *s];
797 }
798
799 sum += sum_block[(unsigned char) front[1]]; /* length */
800 sum += sum_block[(unsigned char) front[2]];
801 sum += sum_block[(unsigned char) front[3]]; /* type */
802 TOHEX (front + 4, sum);
803 if (bfd_write (front, 1, 6, abfd) != 6)
804 abort ();
805 end[0] = '\n';
806 wrlen = end - start + 1;
807 if (bfd_write (start, 1, wrlen, abfd) != wrlen)
808 abort ();
809}
810
811static boolean
812tekhex_write_object_contents (abfd)
813 bfd *abfd;
814{
815 int bytes_written;
816 char buffer[100];
817 asymbol **p;
818 asection *s;
819 struct data_struct *d;
820
821 tekhex_init ();
822
823 bytes_written = 0;
824
825 /* And the raw data */
826 for (d = abfd->tdata.tekhex_data->data;
827 d != (struct data_struct *) NULL;
828 d = d->next)
829 {
830 int low;
831
832 CONST int span = 32;
833 int addr;
834
835 /* Write it in blocks of 32 bytes */
836
837 for (addr = 0; addr < CHUNK_MASK + 1; addr += span)
838 {
839 int need = 0;
840
841 /* Check to see if necessary */
842 for (low = 0; !need && low < span; low++)
843 {
844 if (d->chunk_init[addr + low])
845 need = 1;
846 }
847 if (need)
848 {
849 char *dst = buffer;
850
851 writevalue (&dst, addr + d->vma);
852 for (low = 0; low < span; low++)
853 {
854 TOHEX (dst, d->chunk_data[addr + low]);
855 dst += 2;
856 }
857 out (abfd, '6', buffer, dst);
858 }
859 }
860 }
861 /* write all the section headers for the sections */
862 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
863 {
864 char *dst = buffer;
865
866 writesym (&dst, s->name);
867 *dst++ = '1';
868 writevalue (&dst, s->vma);
869 writevalue (&dst, s->vma + s->_raw_size);
870 out (abfd, '3', buffer, dst);
871 }
872
873 /* And the symbols */
874 if (abfd->outsymbols)
875 {
876 for (p = abfd->outsymbols; *p; p++)
877 {
878 int section_code = bfd_decode_symclass (*p);
879
880 if (section_code != '?')
881 { /* do not include debug symbols */
882 asymbol *s = *p;
883 char *dst = buffer;
884
885 writesym (&dst, s->section->name);
886
887 switch (section_code)
888 {
889 case 'A':
890 *dst++ = '2';
891 break;
892 case 'a':
893 *dst++ = '6';
894 break;
895 case 'D':
896 case 'B':
897 case 'O':
898 *dst++ = '4';
899 break;
900 case 'd':
901 case 'b':
902 case 'o':
903 *dst++ = '8';
904 break;
905 case 'T':
906 *dst++ = '3';
907 break;
908 case 't':
909 *dst++ = '7';
910 break;
911 case 'C':
912 case 'U':
913 bfd_set_error (bfd_error_wrong_format);
914 return false;
915 }
916
917 writesym (&dst, s->name);
918 writevalue (&dst, s->value + s->section->vma);
919 out (abfd, '3', buffer, dst);
920 }
921 }
922 }
923
924 /* And the terminator */
925 if (bfd_write ("%0781010\n", 1, 9, abfd) != 9)
926 abort ();
927 return true;
928}
929
930static int
931tekhex_sizeof_headers (abfd, exec)
7442e600
ILT		 932 bfd *abfd ATTRIBUTE_UNUSED;
933 boolean exec ATTRIBUTE_UNUSED;
252b5132
RH		 934
935{
936 return 0;
937}
938
939static asymbol *
940tekhex_make_empty_symbol (abfd)
941 bfd *abfd;
942{
943 tekhex_symbol_type *new =
944 (tekhex_symbol_type *) bfd_zalloc (abfd, sizeof (struct tekhex_symbol_struct));
945
946 if (!new)
947 return NULL;
948 new->symbol.the_bfd = abfd;
949 new->prev = (struct tekhex_symbol_struct *) NULL;
950 return &(new->symbol);
951}
952
953static void
954tekhex_get_symbol_info (ignore_abfd, symbol, ret)
7442e600 955 bfd *ignore_abfd ATTRIBUTE_UNUSED;
252b5132
RH		 956 asymbol *symbol;
957 symbol_info *ret;
958{
959 bfd_symbol_info (symbol, ret);
960}
961
962static void
963tekhex_print_symbol (ignore_abfd, filep, symbol, how)
7442e600 964 bfd *ignore_abfd ATTRIBUTE_UNUSED;
252b5132
RH		 965 PTR filep;
966 asymbol *symbol;
967 bfd_print_symbol_type how;
968{
969 FILE *file = (FILE *) filep;
970
971 switch (how)
972 {
973 case bfd_print_symbol_name:
974 fprintf (file, "%s", symbol->name);
975 break;
976 case bfd_print_symbol_more:
977 break;
978
979 case bfd_print_symbol_all:
980 {
981 CONST char *section_name = symbol->section->name;
982
983 bfd_print_symbol_vandf ((PTR) file, symbol);
984
985 fprintf (file, " %-5s %s",
986 section_name,
987 symbol->name);
988 }
989 }
990}
991
992#define tekhex_close_and_cleanup _bfd_generic_close_and_cleanup
993#define tekhex_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
994#define tekhex_new_section_hook _bfd_generic_new_section_hook
995
996#define tekhex_bfd_is_local_label_name bfd_generic_is_local_label_name
997#define tekhex_get_lineno _bfd_nosymbols_get_lineno
998#define tekhex_find_nearest_line _bfd_nosymbols_find_nearest_line
999#define tekhex_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
1000#define tekhex_read_minisymbols _bfd_generic_read_minisymbols
1001#define tekhex_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
1002
1003#define tekhex_bfd_get_relocated_section_contents \
1004 bfd_generic_get_relocated_section_contents
1005#define tekhex_bfd_relax_section bfd_generic_relax_section
1006#define tekhex_bfd_gc_sections bfd_generic_gc_sections
1007#define tekhex_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
1008#define tekhex_bfd_link_add_symbols _bfd_generic_link_add_symbols
1009#define tekhex_bfd_final_link _bfd_generic_final_link
1010#define tekhex_bfd_link_split_section _bfd_generic_link_split_section
1011
1012#define tekhex_get_section_contents_in_window \
1013 _bfd_generic_get_section_contents_in_window
1014
1015const bfd_target tekhex_vec =
1016{
1017 "tekhex", /* name */
1018 bfd_target_tekhex_flavour,
1019 BFD_ENDIAN_UNKNOWN, /* target byte order */
1020 BFD_ENDIAN_UNKNOWN, /* target headers byte order */
1021 (EXEC_P | /* object flags */
1022 HAS_SYMS | HAS_LINENO | HAS_DEBUG | HAS_RELOC | HAS_LOCALS |
1023 WP_TEXT | D_PAGED),
1024 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
1025 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
1026 0, /* leading underscore */
1027 ' ', /* ar_pad_char */
1028 16, /* ar_max_namelen */
1029 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1030 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1031 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
1032 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1033 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1034 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
1035
1036 {
1037 _bfd_dummy_target,
1038 tekhex_object_p, /* bfd_check_format */
1039 _bfd_dummy_target,
1040 _bfd_dummy_target,
1041 },
1042 {
1043 bfd_false,
1044 tekhex_mkobject,
1045 _bfd_generic_mkarchive,
1046 bfd_false,
1047 },
1048 { /* bfd_write_contents */
1049 bfd_false,
1050 tekhex_write_object_contents,
1051 _bfd_write_archive_contents,
1052 bfd_false,
1053 },
1054
1055 BFD_JUMP_TABLE_GENERIC (tekhex),
1056 BFD_JUMP_TABLE_COPY (_bfd_generic),
1057 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1058 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1059 BFD_JUMP_TABLE_SYMBOLS (tekhex),
1060 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
1061 BFD_JUMP_TABLE_WRITE (tekhex),
1062 BFD_JUMP_TABLE_LINK (tekhex),
1063 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1064
1065 (PTR) 0
1066};
GDB Binutils - Deliverables
This page took 0.070909 seconds and 4 git commands to generate.