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, 2005, 2006, 2007, 2009, 2011 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 = (struct data_struct *)
 328           bfd_zalloc (abfd, (bfd_size_type) sizeof (struct data_struct));
 329
 330       if (!d)
 331         return NULL;
 332
 333       d->next = abfd->tdata.tekhex_data->data;
 334       d->vma = vma;
 335       abfd->tdata.tekhex_data->data = d;
 336     }
 337   return d;
 338 }
 339
 340 static void
 341 insert_byte (bfd *abfd, int value, bfd_vma addr)
 342 {
 343   /* Find the chunk that this byte needs and put it in.  */
 344   struct data_struct *d = find_chunk (abfd, addr);
 345
 346   d->chunk_data[addr & CHUNK_MASK] = value;
 347   d->chunk_init[addr & CHUNK_MASK] = 1;
 348 }
 349
 350 /* The first pass is to find the names of all the sections, and see
 351   how big the data is.  */
 352
 353 static bfd_boolean
 354 first_phase (bfd *abfd, int type, char *src)
 355 {
 356   asection *section = bfd_abs_section_ptr;
 357   unsigned int len;
 358   bfd_vma val;
 359   char sym[17];                 /* A symbol can only be 16chars long.  */
 360
 361   switch (type)
 362     {
 363     case '6':
 364       /* Data record - read it and store it.  */
 365       {
 366         bfd_vma addr;
 367
 368         if (!getvalue (&src, &addr))
 369           return FALSE;
 370
 371         while (*src)
 372           {
 373             insert_byte (abfd, HEX (src), addr);
 374             src += 2;
 375             addr++;
 376           }
 377       }
 378
 379       return TRUE;
 380     case '3':
 381       /* Symbol record, read the segment.  */
 382       if (!getsym (sym, &src, &len))
 383         return FALSE;
 384       section = bfd_get_section_by_name (abfd, sym);
 385       if (section == NULL)
 386         {
 387           char *n = (char *) bfd_alloc (abfd, (bfd_size_type) len + 1);
 388
 389           if (!n)
 390             return FALSE;
 391           memcpy (n, sym, len + 1);
 392           section = bfd_make_section (abfd, n);
 393           if (section == NULL)
 394             return FALSE;
 395         }
 396       while (*src)
 397         {
 398           switch (*src)
 399             {
 400             case '1':           /* Section range.  */
 401               src++;
 402               if (!getvalue (&src, &section->vma))
 403                 return FALSE;
 404               if (!getvalue (&src, &val))
 405                 return FALSE;
 406               section->size = val - section->vma;
 407               section->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
 408               break;
 409             case '0':
 410             case '2':
 411             case '3':
 412             case '4':
 413             case '6':
 414             case '7':
 415             case '8':
 416               /* Symbols, add to section.  */
 417               {
 418                 bfd_size_type amt = sizeof (tekhex_symbol_type);
 419                 tekhex_symbol_type *new_symbol = (tekhex_symbol_type *)
 420                     bfd_alloc (abfd, amt);
 421                 char stype = (*src);
 422
 423                 if (!new_symbol)
 424                   return FALSE;
 425                 new_symbol->symbol.the_bfd = abfd;
 426                 src++;
 427                 abfd->symcount++;
 428                 abfd->flags |= HAS_SYMS;
 429                 new_symbol->prev = abfd->tdata.tekhex_data->symbols;
 430                 abfd->tdata.tekhex_data->symbols = new_symbol;
 431                 if (!getsym (sym, &src, &len))
 432                   return FALSE;
 433                 new_symbol->symbol.name = (const char *)
 434                     bfd_alloc (abfd, (bfd_size_type) len + 1);
 435                 if (!new_symbol->symbol.name)
 436                   return FALSE;
 437                 memcpy ((char *) (new_symbol->symbol.name), sym, len + 1);
 438                 new_symbol->symbol.section = section;
 439                 if (stype <= '4')
 440                   new_symbol->symbol.flags = (BSF_GLOBAL | BSF_EXPORT);
 441                 else
 442                   new_symbol->symbol.flags = BSF_LOCAL;
 443                 if (!getvalue (&src, &val))
 444                   return FALSE;
 445                 new_symbol->symbol.value = val - section->vma;
 446                 break;
 447               }
 448             default:
 449               return FALSE;
 450             }
 451         }
 452     }
 453
 454   return TRUE;
 455 }
 456
 457 /* Pass over a tekhex, calling one of the above functions on each
 458    record.  */
 459
 460 static bfd_boolean
 461 pass_over (bfd *abfd, bfd_boolean (*func) (bfd *, int, char *))
 462 {
 463   unsigned int chars_on_line;
 464   bfd_boolean is_eof = FALSE;
 465
 466   /* To the front of the file.  */
 467   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 468     return FALSE;
 469   while (! is_eof)
 470     {
 471       char src[MAXCHUNK];
 472       char type;
 473
 474       /* Find first '%'.  */
 475       is_eof = (bfd_boolean) (bfd_bread (src, (bfd_size_type) 1, abfd) != 1);
 476       while (*src != '%' && !is_eof)
 477         is_eof = (bfd_boolean) (bfd_bread (src, (bfd_size_type) 1, abfd) != 1);
 478
 479       if (is_eof)
 480         break;
 481
 482       /* Fetch the type and the length and the checksum.  */
 483       if (bfd_bread (src, (bfd_size_type) 5, abfd) != 5)
 484         return FALSE;
 485
 486       type = src[2];
 487
 488       if (!ISHEX (src[0]) || !ISHEX (src[1]))
 489         break;
 490
 491       /* Already read five chars.  */
 492       chars_on_line = HEX (src) - 5;
 493
 494       if (chars_on_line >= MAXCHUNK)
 495         return FALSE;
 496
 497       if (bfd_bread (src, (bfd_size_type) chars_on_line, abfd) != chars_on_line)
 498         return FALSE;
 499
 500       /* Put a null at the end.  */
 501       src[chars_on_line] = 0;
 502
 503       if (!func (abfd, type, src))
 504         return FALSE;
 505     }
 506
 507   return TRUE;
 508 }
 509
 510 static long
 511 tekhex_canonicalize_symtab (bfd *abfd, asymbol **table)
 512 {
 513   tekhex_symbol_type *p = abfd->tdata.tekhex_data->symbols;
 514   unsigned int c = bfd_get_symcount (abfd);
 515
 516   table[c] = 0;
 517   while (p)
 518     {
 519       table[--c] = &(p->symbol);
 520       p = p->prev;
 521     }
 522
 523   return bfd_get_symcount (abfd);
 524 }
 525
 526 static long
 527 tekhex_get_symtab_upper_bound (bfd *abfd)
 528 {
 529   return (abfd->symcount + 1) * (sizeof (struct tekhex_asymbol_struct *));
 530
 531 }
 532
 533 static bfd_boolean
 534 tekhex_mkobject (bfd *abfd)
 535 {
 536   tdata_type *tdata;
 537
 538   tdata = (tdata_type *) bfd_alloc (abfd, (bfd_size_type) sizeof (tdata_type));
 539   if (!tdata)
 540     return FALSE;
 541   abfd->tdata.tekhex_data = tdata;
 542   tdata->type = 1;
 543   tdata->head =  NULL;
 544   tdata->symbols = NULL;
 545   tdata->data = NULL;
 546   return TRUE;
 547 }
 548
 549 /* Return TRUE if the file looks like it's in TekHex format. Just look
 550    for a percent sign and some hex digits.  */
 551
 552 static const bfd_target *
 553 tekhex_object_p (bfd *abfd)
 554 {
 555   char b[4];
 556
 557   tekhex_init ();
 558
 559   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
 560       || bfd_bread (b, (bfd_size_type) 4, abfd) != 4)
 561     return NULL;
 562
 563   if (b[0] != '%' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3]))
 564     return NULL;
 565
 566   tekhex_mkobject (abfd);
 567
 568   if (!pass_over (abfd, first_phase))
 569     return NULL;
 570
 571   return abfd->xvec;
 572 }
 573
 574 static void
 575 move_section_contents (bfd *abfd,
 576                        asection *section,
 577                        const void * locationp,
 578                        file_ptr offset,
 579                        bfd_size_type count,
 580                        bfd_boolean get)
 581 {
 582   bfd_vma addr;
 583   char *location = (char *) locationp;
 584   bfd_vma prev_number = 1;      /* Nothing can have this as a high bit.  */
 585   struct data_struct *d = NULL;
 586
 587   BFD_ASSERT (offset == 0);
 588   for (addr = section->vma; count != 0; count--, addr++)
 589     {
 590       /* Get high bits of address.  */
 591       bfd_vma chunk_number = addr & ~(bfd_vma) CHUNK_MASK;
 592       bfd_vma low_bits = addr & CHUNK_MASK;
 593
 594       if (chunk_number != prev_number)
 595         /* Different chunk, so move pointer. */
 596         d = find_chunk (abfd, chunk_number);
 597
 598       if (get)
 599         {
 600           if (d->chunk_init[low_bits])
 601             *location = d->chunk_data[low_bits];
 602           else
 603             *location = 0;
 604         }
 605       else
 606         {
 607           d->chunk_data[low_bits] = *location;
 608           d->chunk_init[low_bits] = (*location != 0);
 609         }
 610
 611       location++;
 612     }
 613 }
 614
 615 static bfd_boolean
 616 tekhex_get_section_contents (bfd *abfd,
 617                              asection *section,
 618                              void * locationp,
 619                              file_ptr offset,
 620                              bfd_size_type count)
 621 {
 622   if (section->flags & (SEC_LOAD | SEC_ALLOC))
 623     {
 624       move_section_contents (abfd, section, locationp, offset, count, TRUE);
 625       return TRUE;
 626     }
 627
 628   return FALSE;
 629 }
 630
 631 static bfd_boolean
 632 tekhex_set_arch_mach (bfd *abfd,
 633                       enum bfd_architecture arch,
 634                       unsigned long machine)
 635 {
 636   return bfd_default_set_arch_mach (abfd, arch, machine);
 637 }
 638
 639 /* We have to save up all the Tekhexords for a splurge before output.  */
 640
 641 static bfd_boolean
 642 tekhex_set_section_contents (bfd *abfd,
 643                              sec_ptr section,
 644                              const void * locationp,
 645                              file_ptr offset,
 646                              bfd_size_type bytes_to_do)
 647 {
 648   if (! abfd->output_has_begun)
 649     {
 650       /* The first time around, allocate enough sections to hold all the chunks.  */
 651       asection *s = abfd->sections;
 652       bfd_vma vma;
 653
 654       for (s = abfd->sections; s; s = s->next)
 655         {
 656           if (s->flags & SEC_LOAD)
 657             {
 658               for (vma = s->vma & ~(bfd_vma) CHUNK_MASK;
 659                    vma < s->vma + s->size;
 660                    vma += CHUNK_MASK)
 661                 find_chunk (abfd, vma);
 662             }
 663         }
 664     }
 665
 666   if (section->flags & (SEC_LOAD | SEC_ALLOC))
 667     {
 668       move_section_contents (abfd, section, locationp, offset, bytes_to_do,
 669                              FALSE);
 670       return TRUE;
 671     }
 672
 673   return FALSE;
 674 }
 675
 676 static void
 677 writevalue (char **dst, bfd_vma value)
 678 {
 679   char *p = *dst;
 680   int len;
 681   int shift;
 682
 683   for (len = 8, shift = 28; shift; shift -= 4, len--)
 684     {
 685       if ((value >> shift) & 0xf)
 686         {
 687           *p++ = len + '0';
 688           while (len)
 689             {
 690               *p++ = digs[(value >> shift) & 0xf];
 691               shift -= 4;
 692               len--;
 693             }
 694           *dst = p;
 695           return;
 696
 697         }
 698     }
 699   *p++ = '1';
 700   *p++ = '0';
 701   *dst = p;
 702 }
 703
 704 static void
 705 writesym (char **dst, const char *sym)
 706 {
 707   char *p = *dst;
 708   int len = (sym ? strlen (sym) : 0);
 709
 710   if (len >= 16)
 711     {
 712       *p++ = '0';
 713       len = 16;
 714     }
 715   else
 716     {
 717       if (len == 0)
 718         {
 719           *p++ = '1';
 720           sym = "$";
 721           len = 1;
 722         }
 723       else
 724         *p++ = digs[len];
 725     }
 726
 727   while (len--)
 728     *p++ = *sym++;
 729
 730   *dst = p;
 731 }
 732
 733 static void
 734 out (bfd *abfd, int type, char *start, char *end)
 735 {
 736   int sum = 0;
 737   char *s;
 738   char front[6];
 739   bfd_size_type wrlen;
 740
 741   front[0] = '%';
 742   TOHEX (front + 1, end - start + 5);
 743   front[3] = type;
 744
 745   for (s = start; s < end; s++)
 746     sum += sum_block[(unsigned char) *s];
 747
 748   sum += sum_block[(unsigned char) front[1]];   /* Length.  */
 749   sum += sum_block[(unsigned char) front[2]];
 750   sum += sum_block[(unsigned char) front[3]];   /* Type.  */
 751   TOHEX (front + 4, sum);
 752   if (bfd_bwrite (front, (bfd_size_type) 6, abfd) != 6)
 753     abort ();
 754   end[0] = '\n';
 755   wrlen = end - start + 1;
 756   if (bfd_bwrite (start, wrlen, abfd) != wrlen)
 757     abort ();
 758 }
 759
 760 static bfd_boolean
 761 tekhex_write_object_contents (bfd *abfd)
 762 {
 763   char buffer[100];
 764   asymbol **p;
 765   asection *s;
 766   struct data_struct *d;
 767
 768   tekhex_init ();
 769
 770   /* And the raw data.  */
 771   for (d = abfd->tdata.tekhex_data->data;
 772        d != NULL;
 773        d = d->next)
 774     {
 775       int low;
 776
 777       const int span = 32;
 778       int addr;
 779
 780       /* Write it in blocks of 32 bytes.  */
 781       for (addr = 0; addr < CHUNK_MASK + 1; addr += span)
 782         {
 783           int need = 0;
 784
 785           /* Check to see if necessary.  */
 786           for (low = 0; !need && low < span; low++)
 787             if (d->chunk_init[addr + low])
 788               need = 1;
 789
 790           if (need)
 791             {
 792               char *dst = buffer;
 793
 794               writevalue (&dst, addr + d->vma);
 795               for (low = 0; low < span; low++)
 796                 {
 797                   TOHEX (dst, d->chunk_data[addr + low]);
 798                   dst += 2;
 799                 }
 800               out (abfd, '6', buffer, dst);
 801             }
 802         }
 803     }
 804
 805   /* Write all the section headers for the sections.  */
 806   for (s = abfd->sections; s != NULL; s = s->next)
 807     {
 808       char *dst = buffer;
 809
 810       writesym (&dst, s->name);
 811       *dst++ = '1';
 812       writevalue (&dst, s->vma);
 813       writevalue (&dst, s->vma + s->size);
 814       out (abfd, '3', buffer, dst);
 815     }
 816
 817   /* And the symbols.  */
 818   if (abfd->outsymbols)
 819     {
 820       for (p = abfd->outsymbols; *p; p++)
 821         {
 822           int section_code = bfd_decode_symclass (*p);
 823
 824           if (section_code != '?')
 825             {
 826               /* Do not include debug symbols.  */
 827               asymbol *sym = *p;
 828               char *dst = buffer;
 829
 830               writesym (&dst, sym->section->name);
 831
 832               switch (section_code)
 833                 {
 834                 case 'A':
 835                   *dst++ = '2';
 836                   break;
 837                 case 'a':
 838                   *dst++ = '6';
 839                   break;
 840                 case 'D':
 841                 case 'B':
 842                 case 'O':
 843                   *dst++ = '4';
 844                   break;
 845                 case 'd':
 846                 case 'b':
 847                 case 'o':
 848                   *dst++ = '8';
 849                   break;
 850                 case 'T':
 851                   *dst++ = '3';
 852                   break;
 853                 case 't':
 854                   *dst++ = '7';
 855                   break;
 856                 case 'C':
 857                 case 'U':
 858                   bfd_set_error (bfd_error_wrong_format);
 859                   return FALSE;
 860                 }
 861
 862               writesym (&dst, sym->name);
 863               writevalue (&dst, sym->value + sym->section->vma);
 864               out (abfd, '3', buffer, dst);
 865             }
 866         }
 867     }
 868
 869   /* And the terminator.  */
 870   if (bfd_bwrite ("%0781010\n", (bfd_size_type) 9, abfd) != 9)
 871     abort ();
 872   return TRUE;
 873 }
 874
 875 static int
 876 tekhex_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
 877                        struct bfd_link_info *info ATTRIBUTE_UNUSED)
 878 {
 879   return 0;
 880 }
 881
 882 static asymbol *
 883 tekhex_make_empty_symbol (bfd *abfd)
 884 {
 885   bfd_size_type amt = sizeof (struct tekhex_symbol_struct);
 886   tekhex_symbol_type *new_symbol = (tekhex_symbol_type *) bfd_zalloc (abfd,
 887                                                                       amt);
 888
 889   if (!new_symbol)
 890     return NULL;
 891   new_symbol->symbol.the_bfd = abfd;
 892   new_symbol->prev =  NULL;
 893   return &(new_symbol->symbol);
 894 }
 895
 896 static void
 897 tekhex_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
 898                         asymbol *symbol,
 899                         symbol_info *ret)
 900 {
 901   bfd_symbol_info (symbol, ret);
 902 }
 903
 904 static void
 905 tekhex_print_symbol (bfd *abfd,
 906                      void * filep,
 907                      asymbol *symbol,
 908                      bfd_print_symbol_type how)
 909 {
 910   FILE *file = (FILE *) filep;
 911
 912   switch (how)
 913     {
 914     case bfd_print_symbol_name:
 915       fprintf (file, "%s", symbol->name);
 916       break;
 917     case bfd_print_symbol_more:
 918       break;
 919
 920     case bfd_print_symbol_all:
 921       {
 922         const char *section_name = symbol->section->name;
 923
 924         bfd_print_symbol_vandf (abfd, (void *) file, symbol);
 925
 926         fprintf (file, " %-5s %s",
 927                  section_name, symbol->name);
 928       }
 929     }
 930 }
 931
 932 #define tekhex_close_and_cleanup                    _bfd_generic_close_and_cleanup
 933 #define tekhex_bfd_free_cached_info                 _bfd_generic_bfd_free_cached_info
 934 #define tekhex_new_section_hook                     _bfd_generic_new_section_hook
 935 #define tekhex_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
 936 #define tekhex_bfd_is_local_label_name               bfd_generic_is_local_label_name
 937 #define tekhex_get_lineno                           _bfd_nosymbols_get_lineno
 938 #define tekhex_find_nearest_line                    _bfd_nosymbols_find_nearest_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_hash_table_free             _bfd_generic_link_hash_table_free
 954 #define tekhex_bfd_link_add_symbols                 _bfd_generic_link_add_symbols
 955 #define tekhex_bfd_link_just_syms                   _bfd_generic_link_just_syms
 956 #define tekhex_bfd_copy_link_hash_symbol_type \
 957   _bfd_generic_copy_link_hash_symbol_type
 958 #define tekhex_bfd_final_link                       _bfd_generic_final_link
 959 #define tekhex_bfd_link_split_section               _bfd_generic_link_split_section
 960 #define tekhex_get_section_contents_in_window       _bfd_generic_get_section_contents_in_window
 961
 962 const bfd_target tekhex_vec =
 963 {
 964   "tekhex",                     /* Name.  */
 965   bfd_target_tekhex_flavour,
 966   BFD_ENDIAN_UNKNOWN,           /* Target byte order.  */
 967   BFD_ENDIAN_UNKNOWN,           /* Target headers byte order.  */
 968   (EXEC_P |                     /* Object flags.  */
 969    HAS_SYMS | HAS_LINENO | HAS_DEBUG |
 970    HAS_RELOC | HAS_LOCALS | WP_TEXT | D_PAGED),
 971   (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
 972    | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags.  */
 973   0,                            /* Leading underscore.  */
 974   ' ',                          /* AR_pad_char.  */
 975   16,                           /* AR_max_namelen.  */
 976   0,                            /* match priority.  */
 977   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
 978   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
 979   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Data.  */
 980   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
 981   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
 982   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Headers.  */
 983
 984   {
 985     _bfd_dummy_target,
 986     tekhex_object_p,            /* bfd_check_format.  */
 987     _bfd_dummy_target,
 988     _bfd_dummy_target,
 989   },
 990   {
 991     bfd_false,
 992     tekhex_mkobject,
 993     _bfd_generic_mkarchive,
 994     bfd_false,
 995   },
 996   {                             /* bfd_write_contents.  */
 997     bfd_false,
 998     tekhex_write_object_contents,
 999     _bfd_write_archive_contents,
1000     bfd_false,
1001   },
1002
1003   BFD_JUMP_TABLE_GENERIC (tekhex),
1004   BFD_JUMP_TABLE_COPY (_bfd_generic),
1005   BFD_JUMP_TABLE_CORE (_bfd_nocore),
1006   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1007   BFD_JUMP_TABLE_SYMBOLS (tekhex),
1008   BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
1009   BFD_JUMP_TABLE_WRITE (tekhex),
1010   BFD_JUMP_TABLE_LINK (tekhex),
1011   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1012
1013   NULL,
1014
1015   NULL
1016 };