1 /* BFD backend for Extended Tektronix Hex Format objects. 2 Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, 3 2003, 2004 Free Software Foundation, Inc. 4 Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>. 5 6 This file is part of BFD, the Binary File Descriptor library. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 21 22 /* SUBSECTION 23 Tektronix Hex Format handling 24 25 DESCRIPTION 26 27 Tek Hex records can hold symbols and data, but not 28 relocations. Their main application is communication with 29 devices like PROM programmers and ICE equipment. 30 31 It seems that the sections are described as being really big, 32 the example I have says that the text section is 0..ffffffff. 33 BFD would barf with this, many apps would try to alloc 4GB to 34 read in the file. 35 36 Tex Hex may contain many sections, but the data which comes in 37 has no tag saying which section it belongs to, so we create 38 one section for each block of data, called "blknnnn" which we 39 stick all the data into. 40 41 TekHex may come out of order and there is no header, so an 42 initial scan is required to discover the minimum and maximum 43 addresses used to create the vma and size of the sections we 44 create. 45 We read in the data into pages of CHUNK_MASK+1 size and read 46 them out from that whenever we need to. 47 48 Any number of sections may be created for output, we save them 49 up and output them when it's time to close the bfd. 50 51 A TekHex record looks like: 52 EXAMPLE 53 %<block length><type><checksum><stuff><cr> 54 55 DESCRIPTION 56 Where 57 o length 58 is the number of bytes in the record not including the % sign. 59 o type 60 is one of: 61 3) symbol record 62 6) data record 63 8) termination record 64 65 The data can come out of order, and may be discontigous. This is a 66 serial protocol, so big files are unlikely, so we keep a list of 8k chunks. */ 67 68 #include "bfd.h" 69 #include "sysdep.h" 70 #include "libbfd.h" 71 #include "libiberty.h" 72 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 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 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 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 * 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 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 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 } 440 default: 441 return FALSE; 442 } 443 } 444 } 445 446 return TRUE; 447 } 448 449 /* Pass over a tekhex, calling one of the above functions on each 450 record. */ 451 452 static bfd_boolean 453 pass_over (bfd *abfd, bfd_boolean (*func) (bfd *, int, char *)) 454 { 455 unsigned int chars_on_line; 456 bfd_boolean eof = FALSE; 457 458 /* To the front of the file. */ 459 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) 460 abort (); 461 while (! eof) 462 { 463 char buffer[MAXCHUNK]; 464 char *src = buffer; 465 char type; 466 467 /* Find first '%'. */ 468 eof = (bfd_boolean) (bfd_bread (src, (bfd_size_type) 1, abfd) != 1); 469 while (*src != '%' && !eof) 470 eof = (bfd_boolean) (bfd_bread (src, (bfd_size_type) 1, abfd) != 1); 471 472 if (eof) 473 break; 474 src++; 475 476 /* Fetch the type and the length and the checksum. */ 477 if (bfd_bread (src, (bfd_size_type) 5, abfd) != 5) 478 abort (); /* FIXME. */ 479 480 type = src[2]; 481 482 if (!ISHEX (src[0]) || !ISHEX (src[1])) 483 break; 484 485 /* Already read five char. */ 486 chars_on_line = HEX (src) - 5; 487 488 if (bfd_bread (src, (bfd_size_type) chars_on_line, abfd) != chars_on_line) 489 abort (); /* FIXME. */ 490 491 /* Put a null at the end. */ 492 src[chars_on_line] = 0; 493 494 if (!func (abfd, type, src)) 495 return FALSE; 496 } 497 498 return TRUE; 499 } 500 501 static long 502 tekhex_canonicalize_symtab (bfd *abfd, asymbol **table) 503 { 504 tekhex_symbol_type *p = abfd->tdata.tekhex_data->symbols; 505 unsigned int c = bfd_get_symcount (abfd); 506 507 table[c] = 0; 508 while (p) 509 { 510 table[--c] = &(p->symbol); 511 p = p->prev; 512 } 513 514 return bfd_get_symcount (abfd); 515 } 516 517 static long 518 tekhex_get_symtab_upper_bound (bfd *abfd) 519 { 520 return (abfd->symcount + 1) * (sizeof (struct tekhex_asymbol_struct *)); 521 522 } 523 524 static bfd_boolean 525 tekhex_mkobject (bfd *abfd) 526 { 527 tdata_type *tdata; 528 529 tdata = bfd_alloc (abfd, (bfd_size_type) sizeof (tdata_type)); 530 if (!tdata) 531 return FALSE; 532 abfd->tdata.tekhex_data = tdata; 533 tdata->type = 1; 534 tdata->head = NULL; 535 tdata->symbols = NULL; 536 tdata->data = NULL; 537 return TRUE; 538 } 539 540 /* Return TRUE if the file looks like it's in TekHex format. Just look 541 for a percent sign and some hex digits. */ 542 543 static const bfd_target * 544 tekhex_object_p (bfd *abfd) 545 { 546 char b[4]; 547 548 tekhex_init (); 549 550 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0 551 || bfd_bread (b, (bfd_size_type) 4, abfd) != 4) 552 return NULL; 553 554 if (b[0] != '%' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3])) 555 return NULL; 556 557 tekhex_mkobject (abfd); 558 559 if (!pass_over (abfd, first_phase)) 560 return NULL; 561 562 return abfd->xvec; 563 } 564 565 static void 566 move_section_contents (bfd *abfd, 567 asection *section, 568 const void * locationp, 569 file_ptr offset, 570 bfd_size_type count, 571 bfd_boolean get) 572 { 573 bfd_vma addr; 574 char *location = (char *) locationp; 575 bfd_vma prev_number = 1; /* Nothing can have this as a high bit. */ 576 struct data_struct *d = NULL; 577 578 BFD_ASSERT (offset == 0); 579 for (addr = section->vma; count != 0; count--, addr++) 580 { 581 /* Get high bits of address. */ 582 bfd_vma chunk_number = addr & ~(bfd_vma) CHUNK_MASK; 583 bfd_vma low_bits = addr & CHUNK_MASK; 584 585 if (chunk_number != prev_number) 586 /* Different chunk, so move pointer. */ 587 d = find_chunk (abfd, chunk_number); 588 589 if (get) 590 { 591 if (d->chunk_init[low_bits]) 592 *location = d->chunk_data[low_bits]; 593 else 594 *location = 0; 595 } 596 else 597 { 598 d->chunk_data[low_bits] = *location; 599 d->chunk_init[low_bits] = (*location != 0); 600 } 601 602 location++; 603 } 604 } 605 606 static bfd_boolean 607 tekhex_get_section_contents (bfd *abfd, 608 asection *section, 609 void * locationp, 610 file_ptr offset, 611 bfd_size_type count) 612 { 613 if (section->flags & (SEC_LOAD | SEC_ALLOC)) 614 { 615 move_section_contents (abfd, section, locationp, offset, count, TRUE); 616 return TRUE; 617 } 618 619 return FALSE; 620 } 621 622 static bfd_boolean 623 tekhex_set_arch_mach (bfd *abfd, 624 enum bfd_architecture arch, 625 unsigned long machine) 626 { 627 return bfd_default_set_arch_mach (abfd, arch, machine); 628 } 629 630 /* We have to save up all the Tekhexords for a splurge before output. */ 631 632 static bfd_boolean 633 tekhex_set_section_contents (bfd *abfd, 634 sec_ptr section, 635 const void * locationp, 636 file_ptr offset, 637 bfd_size_type bytes_to_do) 638 { 639 if (! abfd->output_has_begun) 640 { 641 /* The first time around, allocate enough sections to hold all the chunks. */ 642 asection *s = abfd->sections; 643 bfd_vma vma; 644 645 for (s = abfd->sections; s; s = s->next) 646 { 647 if (s->flags & SEC_LOAD) 648 { 649 for (vma = s->vma & ~(bfd_vma) CHUNK_MASK; 650 vma < s->vma + s->size; 651 vma += CHUNK_MASK) 652 find_chunk (abfd, vma); 653 } 654 } 655 } 656 657 if (section->flags & (SEC_LOAD | SEC_ALLOC)) 658 { 659 move_section_contents (abfd, section, locationp, offset, bytes_to_do, 660 FALSE); 661 return TRUE; 662 } 663 664 return FALSE; 665 } 666 667 static void 668 writevalue (char **dst, bfd_vma value) 669 { 670 char *p = *dst; 671 int len; 672 int shift; 673 674 for (len = 8, shift = 28; shift; shift -= 4, len--) 675 { 676 if ((value >> shift) & 0xf) 677 { 678 *p++ = len + '0'; 679 while (len) 680 { 681 *p++ = digs[(value >> shift) & 0xf]; 682 shift -= 4; 683 len--; 684 } 685 *dst = p; 686 return; 687 688 } 689 } 690 *p++ = '1'; 691 *p++ = '0'; 692 *dst = p; 693 } 694 695 static void 696 writesym (char **dst, const char *sym) 697 { 698 char *p = *dst; 699 int len = (sym ? strlen (sym) : 0); 700 701 if (len >= 16) 702 { 703 *p++ = '0'; 704 len = 16; 705 } 706 else 707 { 708 if (len == 0) 709 { 710 *p++ = '1'; 711 sym = "$"; 712 len = 1; 713 } 714 else 715 *p++ = digs[len]; 716 } 717 718 while (len--) 719 *p++ = *sym++; 720 721 *dst = p; 722 } 723 724 static void 725 out (bfd *abfd, int type, char *start, char *end) 726 { 727 int sum = 0; 728 char *s; 729 char front[6]; 730 bfd_size_type wrlen; 731 732 front[0] = '%'; 733 TOHEX (front + 1, end - start + 5); 734 front[3] = type; 735 736 for (s = start; s < end; s++) 737 sum += sum_block[(unsigned char) *s]; 738 739 sum += sum_block[(unsigned char) front[1]]; /* Length. */ 740 sum += sum_block[(unsigned char) front[2]]; 741 sum += sum_block[(unsigned char) front[3]]; /* Type. */ 742 TOHEX (front + 4, sum); 743 if (bfd_bwrite (front, (bfd_size_type) 6, abfd) != 6) 744 abort (); 745 end[0] = '\n'; 746 wrlen = end - start + 1; 747 if (bfd_bwrite (start, wrlen, abfd) != wrlen) 748 abort (); 749 } 750 751 static bfd_boolean 752 tekhex_write_object_contents (bfd *abfd) 753 { 754 int bytes_written; 755 char buffer[100]; 756 asymbol **p; 757 asection *s; 758 struct data_struct *d; 759 760 tekhex_init (); 761 762 bytes_written = 0; 763 764 /* And the raw data. */ 765 for (d = abfd->tdata.tekhex_data->data; 766 d != NULL; 767 d = d->next) 768 { 769 int low; 770 771 const int span = 32; 772 int addr; 773 774 /* Write it in blocks of 32 bytes. */ 775 for (addr = 0; addr < CHUNK_MASK + 1; addr += span) 776 { 777 int need = 0; 778 779 /* Check to see if necessary. */ 780 for (low = 0; !need && low < span; low++) 781 if (d->chunk_init[addr + low]) 782 need = 1; 783 784 if (need) 785 { 786 char *dst = buffer; 787 788 writevalue (&dst, addr + d->vma); 789 for (low = 0; low < span; low++) 790 { 791 TOHEX (dst, d->chunk_data[addr + low]); 792 dst += 2; 793 } 794 out (abfd, '6', buffer, dst); 795 } 796 } 797 } 798 799 /* Write all the section headers for the sections. */ 800 for (s = abfd->sections; s != NULL; s = s->next) 801 { 802 char *dst = buffer; 803 804 writesym (&dst, s->name); 805 *dst++ = '1'; 806 writevalue (&dst, s->vma); 807 writevalue (&dst, s->vma + s->size); 808 out (abfd, '3', buffer, dst); 809 } 810 811 /* And the symbols. */ 812 if (abfd->outsymbols) 813 { 814 for (p = abfd->outsymbols; *p; p++) 815 { 816 int section_code = bfd_decode_symclass (*p); 817 818 if (section_code != '?') 819 { 820 /* Do not include debug symbols. */ 821 asymbol *sym = *p; 822 char *dst = buffer; 823 824 writesym (&dst, sym->section->name); 825 826 switch (section_code) 827 { 828 case 'A': 829 *dst++ = '2'; 830 break; 831 case 'a': 832 *dst++ = '6'; 833 break; 834 case 'D': 835 case 'B': 836 case 'O': 837 *dst++ = '4'; 838 break; 839 case 'd': 840 case 'b': 841 case 'o': 842 *dst++ = '8'; 843 break; 844 case 'T': 845 *dst++ = '3'; 846 break; 847 case 't': 848 *dst++ = '7'; 849 break; 850 case 'C': 851 case 'U': 852 bfd_set_error (bfd_error_wrong_format); 853 return FALSE; 854 } 855 856 writesym (&dst, sym->name); 857 writevalue (&dst, sym->value + sym->section->vma); 858 out (abfd, '3', buffer, dst); 859 } 860 } 861 } 862 863 /* And the terminator. */ 864 if (bfd_bwrite ("%0781010\n", (bfd_size_type) 9, abfd) != 9) 865 abort (); 866 return TRUE; 867 } 868 869 static int 870 tekhex_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED, 871 bfd_boolean exec ATTRIBUTE_UNUSED) 872 { 873 return 0; 874 } 875 876 static asymbol * 877 tekhex_make_empty_symbol (bfd *abfd) 878 { 879 bfd_size_type amt = sizeof (struct tekhex_symbol_struct); 880 tekhex_symbol_type *new = bfd_zalloc (abfd, amt); 881 882 if (!new) 883 return NULL; 884 new->symbol.the_bfd = abfd; 885 new->prev = NULL; 886 return &(new->symbol); 887 } 888 889 static void 890 tekhex_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED, 891 asymbol *symbol, 892 symbol_info *ret) 893 { 894 bfd_symbol_info (symbol, ret); 895 } 896 897 static void 898 tekhex_print_symbol (bfd *abfd, 899 void * filep, 900 asymbol *symbol, 901 bfd_print_symbol_type how) 902 { 903 FILE *file = (FILE *) filep; 904 905 switch (how) 906 { 907 case bfd_print_symbol_name: 908 fprintf (file, "%s", symbol->name); 909 break; 910 case bfd_print_symbol_more: 911 break; 912 913 case bfd_print_symbol_all: 914 { 915 const char *section_name = symbol->section->name; 916 917 bfd_print_symbol_vandf (abfd, (void *) file, symbol); 918 919 fprintf (file, " %-5s %s", 920 section_name, symbol->name); 921 } 922 } 923 } 924 925 #define tekhex_close_and_cleanup _bfd_generic_close_and_cleanup 926 #define tekhex_bfd_free_cached_info _bfd_generic_bfd_free_cached_info 927 #define tekhex_new_section_hook _bfd_generic_new_section_hook 928 #define tekhex_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false) 929 #define tekhex_bfd_is_local_label_name bfd_generic_is_local_label_name 930 #define tekhex_get_lineno _bfd_nosymbols_get_lineno 931 #define tekhex_find_nearest_line _bfd_nosymbols_find_nearest_line 932 #define tekhex_find_inliner_info _bfd_nosymbols_find_inliner_info 933 #define tekhex_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol 934 #define tekhex_read_minisymbols _bfd_generic_read_minisymbols 935 #define tekhex_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol 936 #define tekhex_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents 937 #define tekhex_bfd_relax_section bfd_generic_relax_section 938 #define tekhex_bfd_gc_sections bfd_generic_gc_sections 939 #define tekhex_bfd_merge_sections bfd_generic_merge_sections 940 #define tekhex_bfd_is_group_section bfd_generic_is_group_section 941 #define tekhex_bfd_discard_group bfd_generic_discard_group 942 #define tekhex_section_already_linked _bfd_generic_section_already_linked 943 #define tekhex_bfd_link_hash_table_create _bfd_generic_link_hash_table_create 944 #define tekhex_bfd_link_hash_table_free _bfd_generic_link_hash_table_free 945 #define tekhex_bfd_link_add_symbols _bfd_generic_link_add_symbols 946 #define tekhex_bfd_link_just_syms _bfd_generic_link_just_syms 947 #define tekhex_bfd_final_link _bfd_generic_final_link 948 #define tekhex_bfd_link_split_section _bfd_generic_link_split_section 949 #define tekhex_get_section_contents_in_window _bfd_generic_get_section_contents_in_window 950 951 const bfd_target tekhex_vec = 952 { 953 "tekhex", /* Name. */ 954 bfd_target_tekhex_flavour, 955 BFD_ENDIAN_UNKNOWN, /* Target byte order. */ 956 BFD_ENDIAN_UNKNOWN, /* Target headers byte order. */ 957 (EXEC_P | /* Object flags. */ 958 HAS_SYMS | HAS_LINENO | HAS_DEBUG | 959 HAS_RELOC | HAS_LOCALS | WP_TEXT | D_PAGED), 960 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS 961 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags. */ 962 0, /* Leading underscore. */ 963 ' ', /* AR_pad_char. */ 964 16, /* AR_max_namelen. */ 965 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 966 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 967 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */ 968 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 969 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 970 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Headers. */ 971 972 { 973 _bfd_dummy_target, 974 tekhex_object_p, /* bfd_check_format. */ 975 _bfd_dummy_target, 976 _bfd_dummy_target, 977 }, 978 { 979 bfd_false, 980 tekhex_mkobject, 981 _bfd_generic_mkarchive, 982 bfd_false, 983 }, 984 { /* bfd_write_contents. */ 985 bfd_false, 986 tekhex_write_object_contents, 987 _bfd_write_archive_contents, 988 bfd_false, 989 }, 990 991 BFD_JUMP_TABLE_GENERIC (tekhex), 992 BFD_JUMP_TABLE_COPY (_bfd_generic), 993 BFD_JUMP_TABLE_CORE (_bfd_nocore), 994 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive), 995 BFD_JUMP_TABLE_SYMBOLS (tekhex), 996 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs), 997 BFD_JUMP_TABLE_WRITE (tekhex), 998 BFD_JUMP_TABLE_LINK (tekhex), 999 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), 1000 1001 NULL, 1002 1003 NULL 1004 }; 1005