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