bfd/tekhex.c

   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 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 "sysdep.h"
  69 #include "bfd.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, &section->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                 break;
 440               }
 441             default:
 442               return FALSE;
 443             }
 444         }
 445     }
 446
 447   return TRUE;
 448 }
 449
 450 /* Pass over a tekhex, calling one of the above functions on each
 451    record.  */
 452
 453 static bfd_boolean
 454 pass_over (bfd *abfd, bfd_boolean (*func) (bfd *, int, char *))
 455 {
 456   unsigned int chars_on_line;
 457   bfd_boolean eof = FALSE;
 458
 459   /* To the front of the file.  */
 460   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 461     return FALSE;
 462   while (! eof)
 463     {
 464       char src[MAXCHUNK];
 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
 475       /* Fetch the type and the length and the checksum.  */
 476       if (bfd_bread (src, (bfd_size_type) 5, abfd) != 5)
 477         return FALSE;
 478
 479       type = src[2];
 480
 481       if (!ISHEX (src[0]) || !ISHEX (src[1]))
 482         break;
 483
 484       /* Already read five chars.  */
 485       chars_on_line = HEX (src) - 5;
 486
 487       if (chars_on_line >= MAXCHUNK)
 488         return FALSE;
 489
 490       if (bfd_bread (src, (bfd_size_type) chars_on_line, abfd) != chars_on_line)
 491         return FALSE;
 492
 493       /* Put a null at the end.  */
 494       src[chars_on_line] = 0;
 495
 496       if (!func (abfd, type, src))
 497         return FALSE;
 498     }
 499
 500   return TRUE;
 501 }
 502
 503 static long
 504 tekhex_canonicalize_symtab (bfd *abfd, asymbol **table)
 505 {
 506   tekhex_symbol_type *p = abfd->tdata.tekhex_data->symbols;
 507   unsigned int c = bfd_get_symcount (abfd);
 508
 509   table[c] = 0;
 510   while (p)
 511     {
 512       table[--c] = &(p->symbol);
 513       p = p->prev;
 514     }
 515
 516   return bfd_get_symcount (abfd);
 517 }
 518
 519 static long
 520 tekhex_get_symtab_upper_bound (bfd *abfd)
 521 {
 522   return (abfd->symcount + 1) * (sizeof (struct tekhex_asymbol_struct *));
 523
 524 }
 525
 526 static bfd_boolean
 527 tekhex_mkobject (bfd *abfd)
 528 {
 529   tdata_type *tdata;
 530
 531   tdata = bfd_alloc (abfd, (bfd_size_type) sizeof (tdata_type));
 532   if (!tdata)
 533     return FALSE;
 534   abfd->tdata.tekhex_data = tdata;
 535   tdata->type = 1;
 536   tdata->head =  NULL;
 537   tdata->symbols = NULL;
 538   tdata->data = NULL;
 539   return TRUE;
 540 }
 541
 542 /* Return TRUE if the file looks like it's in TekHex format. Just look
 543    for a percent sign and some hex digits.  */
 544
 545 static const bfd_target *
 546 tekhex_object_p (bfd *abfd)
 547 {
 548   char b[4];
 549
 550   tekhex_init ();
 551
 552   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
 553       || bfd_bread (b, (bfd_size_type) 4, abfd) != 4)
 554     return NULL;
 555
 556   if (b[0] != '%' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3]))
 557     return NULL;
 558
 559   tekhex_mkobject (abfd);
 560
 561   if (!pass_over (abfd, first_phase))
 562     return NULL;
 563
 564   return abfd->xvec;
 565 }
 566
 567 static void
 568 move_section_contents (bfd *abfd,
 569                        asection *section,
 570                        const void * locationp,
 571                        file_ptr offset,
 572                        bfd_size_type count,
 573                        bfd_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 = NULL;
 579
 580   BFD_ASSERT (offset == 0);
 581   for (addr = section->vma; count != 0; count--, addr++)
 582     {
 583       /* Get high bits of address.  */
 584       bfd_vma chunk_number = addr & ~(bfd_vma) CHUNK_MASK;
 585       bfd_vma low_bits = addr & CHUNK_MASK;
 586
 587       if (chunk_number != prev_number)
 588         /* Different chunk, so move pointer. */
 589         d = find_chunk (abfd, chunk_number);
 590
 591       if (get)
 592         {
 593           if (d->chunk_init[low_bits])
 594             *location = d->chunk_data[low_bits];
 595           else
 596             *location = 0;
 597         }
 598       else
 599         {
 600           d->chunk_data[low_bits] = *location;
 601           d->chunk_init[low_bits] = (*location != 0);
 602         }
 603
 604       location++;
 605     }
 606 }
 607
 608 static bfd_boolean
 609 tekhex_get_section_contents (bfd *abfd,
 610                              asection *section,
 611                              void * locationp,
 612                              file_ptr offset,
 613                              bfd_size_type count)
 614 {
 615   if (section->flags & (SEC_LOAD | SEC_ALLOC))
 616     {
 617       move_section_contents (abfd, section, locationp, offset, count, TRUE);
 618       return TRUE;
 619     }
 620
 621   return FALSE;
 622 }
 623
 624 static bfd_boolean
 625 tekhex_set_arch_mach (bfd *abfd,
 626                       enum bfd_architecture arch,
 627                       unsigned long machine)
 628 {
 629   return bfd_default_set_arch_mach (abfd, arch, machine);
 630 }
 631
 632 /* We have to save up all the Tekhexords for a splurge before output.  */
 633
 634 static bfd_boolean
 635 tekhex_set_section_contents (bfd *abfd,
 636                              sec_ptr section,
 637                              const void * locationp,
 638                              file_ptr offset,
 639                              bfd_size_type bytes_to_do)
 640 {
 641   if (! abfd->output_has_begun)
 642     {
 643       /* The first time around, allocate enough sections to hold all the chunks.  */
 644       asection *s = abfd->sections;
 645       bfd_vma vma;
 646
 647       for (s = abfd->sections; s; s = s->next)
 648         {
 649           if (s->flags & SEC_LOAD)
 650             {
 651               for (vma = s->vma & ~(bfd_vma) CHUNK_MASK;
 652                    vma < s->vma + s->size;
 653                    vma += CHUNK_MASK)
 654                 find_chunk (abfd, vma);
 655             }
 656         }
 657     }
 658
 659   if (section->flags & (SEC_LOAD | SEC_ALLOC))
 660     {
 661       move_section_contents (abfd, section, locationp, offset, bytes_to_do,
 662                              FALSE);
 663       return TRUE;
 664     }
 665
 666   return FALSE;
 667 }
 668
 669 static void
 670 writevalue (char **dst, bfd_vma value)
 671 {
 672   char *p = *dst;
 673   int len;
 674   int shift;
 675
 676   for (len = 8, shift = 28; shift; shift -= 4, len--)
 677     {
 678       if ((value >> shift) & 0xf)
 679         {
 680           *p++ = len + '0';
 681           while (len)
 682             {
 683               *p++ = digs[(value >> shift) & 0xf];
 684               shift -= 4;
 685               len--;
 686             }
 687           *dst = p;
 688           return;
 689
 690         }
 691     }
 692   *p++ = '1';
 693   *p++ = '0';
 694   *dst = p;
 695 }
 696
 697 static void
 698 writesym (char **dst, const char *sym)
 699 {
 700   char *p = *dst;
 701   int len = (sym ? strlen (sym) : 0);
 702
 703   if (len >= 16)
 704     {
 705       *p++ = '0';
 706       len = 16;
 707     }
 708   else
 709     {
 710       if (len == 0)
 711         {
 712           *p++ = '1';
 713           sym = "$";
 714           len = 1;
 715         }
 716       else
 717         *p++ = digs[len];
 718     }
 719
 720   while (len--)
 721     *p++ = *sym++;
 722
 723   *dst = p;
 724 }
 725
 726 static void
 727 out (bfd *abfd, int type, char *start, char *end)
 728 {
 729   int sum = 0;
 730   char *s;
 731   char front[6];
 732   bfd_size_type wrlen;
 733
 734   front[0] = '%';
 735   TOHEX (front + 1, end - start + 5);
 736   front[3] = type;
 737
 738   for (s = start; s < end; s++)
 739     sum += sum_block[(unsigned char) *s];
 740
 741   sum += sum_block[(unsigned char) front[1]];   /* Length.  */
 742   sum += sum_block[(unsigned char) front[2]];
 743   sum += sum_block[(unsigned char) front[3]];   /* Type.  */
 744   TOHEX (front + 4, sum);
 745   if (bfd_bwrite (front, (bfd_size_type) 6, abfd) != 6)
 746     abort ();
 747   end[0] = '\n';
 748   wrlen = end - start + 1;
 749   if (bfd_bwrite (start, wrlen, abfd) != wrlen)
 750     abort ();
 751 }
 752
 753 static bfd_boolean
 754 tekhex_write_object_contents (bfd *abfd)
 755 {
 756   char buffer[100];
 757   asymbol **p;
 758   asection *s;
 759   struct data_struct *d;
 760
 761   tekhex_init ();
 762
 763   /* And the raw data.  */
 764   for (d = abfd->tdata.tekhex_data->data;
 765        d != NULL;
 766        d = d->next)
 767     {
 768       int low;
 769
 770       const int span = 32;
 771       int addr;
 772
 773       /* Write it in blocks of 32 bytes.  */
 774       for (addr = 0; addr < CHUNK_MASK + 1; addr += span)
 775         {
 776           int need = 0;
 777
 778           /* Check to see if necessary.  */
 779           for (low = 0; !need && low < span; low++)
 780             if (d->chunk_init[addr + low])
 781               need = 1;
 782
 783           if (need)
 784             {
 785               char *dst = buffer;
 786
 787               writevalue (&dst, addr + d->vma);
 788               for (low = 0; low < span; low++)
 789                 {
 790                   TOHEX (dst, d->chunk_data[addr + low]);
 791                   dst += 2;
 792                 }
 793               out (abfd, '6', buffer, dst);
 794             }
 795         }
 796     }
 797
 798   /* Write all the section headers for the sections.  */
 799   for (s = abfd->sections; s != NULL; s = s->next)
 800     {
 801       char *dst = buffer;
 802
 803       writesym (&dst, s->name);
 804       *dst++ = '1';
 805       writevalue (&dst, s->vma);
 806       writevalue (&dst, s->vma + s->size);
 807       out (abfd, '3', buffer, dst);
 808     }
 809
 810   /* And the symbols.  */
 811   if (abfd->outsymbols)
 812     {
 813       for (p = abfd->outsymbols; *p; p++)
 814         {
 815           int section_code = bfd_decode_symclass (*p);
 816
 817           if (section_code != '?')
 818             {
 819               /* Do not include debug symbols.  */
 820               asymbol *sym = *p;
 821               char *dst = buffer;
 822
 823               writesym (&dst, sym->section->name);
 824
 825               switch (section_code)
 826                 {
 827                 case 'A':
 828                   *dst++ = '2';
 829                   break;
 830                 case 'a':
 831                   *dst++ = '6';
 832                   break;
 833                 case 'D':
 834                 case 'B':
 835                 case 'O':
 836                   *dst++ = '4';
 837                   break;
 838                 case 'd':
 839                 case 'b':
 840                 case 'o':
 841                   *dst++ = '8';
 842                   break;
 843                 case 'T':
 844                   *dst++ = '3';
 845                   break;
 846                 case 't':
 847                   *dst++ = '7';
 848                   break;
 849                 case 'C':
 850                 case 'U':
 851                   bfd_set_error (bfd_error_wrong_format);
 852                   return FALSE;
 853                 }
 854
 855               writesym (&dst, sym->name);
 856               writevalue (&dst, sym->value + sym->section->vma);
 857               out (abfd, '3', buffer, dst);
 858             }
 859         }
 860     }
 861
 862   /* And the terminator.  */
 863   if (bfd_bwrite ("%0781010\n", (bfd_size_type) 9, abfd) != 9)
 864     abort ();
 865   return TRUE;
 866 }
 867
 868 static int
 869 tekhex_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
 870                        struct bfd_link_info *info ATTRIBUTE_UNUSED)
 871 {
 872   return 0;
 873 }
 874
 875 static asymbol *
 876 tekhex_make_empty_symbol (bfd *abfd)
 877 {
 878   bfd_size_type amt = sizeof (struct tekhex_symbol_struct);
 879   tekhex_symbol_type *new = bfd_zalloc (abfd, amt);
 880
 881   if (!new)
 882     return NULL;
 883   new->symbol.the_bfd = abfd;
 884   new->prev =  NULL;
 885   return &(new->symbol);
 886 }
 887
 888 static void
 889 tekhex_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
 890                         asymbol *symbol,
 891                         symbol_info *ret)
 892 {
 893   bfd_symbol_info (symbol, ret);
 894 }
 895
 896 static void
 897 tekhex_print_symbol (bfd *abfd,
 898                      void * filep,
 899                      asymbol *symbol,
 900                      bfd_print_symbol_type how)
 901 {
 902   FILE *file = (FILE *) filep;
 903
 904   switch (how)
 905     {
 906     case bfd_print_symbol_name:
 907       fprintf (file, "%s", symbol->name);
 908       break;
 909     case bfd_print_symbol_more:
 910       break;
 911
 912     case bfd_print_symbol_all:
 913       {
 914         const char *section_name = symbol->section->name;
 915
 916         bfd_print_symbol_vandf (abfd, (void *) file, symbol);
 917
 918         fprintf (file, " %-5s %s",
 919                  section_name, symbol->name);
 920       }
 921     }
 922 }
 923
 924 #define tekhex_close_and_cleanup                    _bfd_generic_close_and_cleanup
 925 #define tekhex_bfd_free_cached_info                 _bfd_generic_bfd_free_cached_info
 926 #define tekhex_new_section_hook                     _bfd_generic_new_section_hook
 927 #define tekhex_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
 928 #define tekhex_bfd_is_local_label_name               bfd_generic_is_local_label_name
 929 #define tekhex_get_lineno                           _bfd_nosymbols_get_lineno
 930 #define tekhex_find_nearest_line                    _bfd_nosymbols_find_nearest_line
 931 #define tekhex_find_inliner_info                    _bfd_nosymbols_find_inliner_info
 932 #define tekhex_bfd_make_debug_symbol                _bfd_nosymbols_bfd_make_debug_symbol
 933 #define tekhex_read_minisymbols                     _bfd_generic_read_minisymbols
 934 #define tekhex_minisymbol_to_symbol                 _bfd_generic_minisymbol_to_symbol
 935 #define tekhex_bfd_get_relocated_section_contents   bfd_generic_get_relocated_section_contents
 936 #define tekhex_bfd_relax_section                    bfd_generic_relax_section
 937 #define tekhex_bfd_gc_sections                      bfd_generic_gc_sections
 938 #define tekhex_bfd_merge_sections                   bfd_generic_merge_sections
 939 #define tekhex_bfd_is_group_section                 bfd_generic_is_group_section
 940 #define tekhex_bfd_discard_group                    bfd_generic_discard_group
 941 #define tekhex_section_already_linked               _bfd_generic_section_already_linked
 942 #define tekhex_bfd_link_hash_table_create           _bfd_generic_link_hash_table_create
 943 #define tekhex_bfd_link_hash_table_free             _bfd_generic_link_hash_table_free
 944 #define tekhex_bfd_link_add_symbols                 _bfd_generic_link_add_symbols
 945 #define tekhex_bfd_link_just_syms                   _bfd_generic_link_just_syms
 946 #define tekhex_bfd_final_link                       _bfd_generic_final_link
 947 #define tekhex_bfd_link_split_section               _bfd_generic_link_split_section
 948 #define tekhex_get_section_contents_in_window       _bfd_generic_get_section_contents_in_window
 949
 950 const bfd_target tekhex_vec =
 951 {
 952   "tekhex",                     /* Name.  */
 953   bfd_target_tekhex_flavour,
 954   BFD_ENDIAN_UNKNOWN,           /* Target byte order.  */
 955   BFD_ENDIAN_UNKNOWN,           /* Target headers byte order.  */
 956   (EXEC_P |                     /* Object flags.  */
 957    HAS_SYMS | HAS_LINENO | HAS_DEBUG |
 958    HAS_RELOC | HAS_LOCALS | 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   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
 965   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
 966   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Data.  */
 967   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
 968   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
 969   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Headers.  */
 970
 971   {
 972     _bfd_dummy_target,
 973     tekhex_object_p,            /* bfd_check_format.  */
 974     _bfd_dummy_target,
 975     _bfd_dummy_target,
 976   },
 977   {
 978     bfd_false,
 979     tekhex_mkobject,
 980     _bfd_generic_mkarchive,
 981     bfd_false,
 982   },
 983   {                             /* bfd_write_contents.  */
 984     bfd_false,
 985     tekhex_write_object_contents,
 986     _bfd_write_archive_contents,
 987     bfd_false,
 988   },
 989
 990   BFD_JUMP_TABLE_GENERIC (tekhex),
 991   BFD_JUMP_TABLE_COPY (_bfd_generic),
 992   BFD_JUMP_TABLE_CORE (_bfd_nocore),
 993   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
 994   BFD_JUMP_TABLE_SYMBOLS (tekhex),
 995   BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
 996   BFD_JUMP_TABLE_WRITE (tekhex),
 997   BFD_JUMP_TABLE_LINK (tekhex),
 998   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 999
1000   NULL,
1001
1002   NULL
1003 };