bfd/tekhex.c

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